@sjcrh/proteinpaint-client 2.180.0 → 2.180.1

package/dist/chunk-NF34NHZM.js

@@ -0,0 +1,4945 @@
+import {
+  rehydrateFilter
+} from "./chunk-SKMFMGCD.js";
+import {
+  showLDlegend
+} from "./chunk-46COTHPZ.js";
+import {
+  legend_newrow
+} from "./chunk-4VGSBYQC.js";
+import {
+  urlmap_default
+} from "./chunk-AQ4OP4GR.js";
+import {
+  ColorScale,
+  Tabs,
+  axisstyle,
+  fillTermWrapper,
+  fillbar,
+  makeNumericAxisConfig,
+  makeSsmLink,
+  make_radios,
+  newSandboxDiv,
+  renderCnvConfig,
+  renderTable,
+  shapeSelector,
+  shapes,
+  table2col,
+  to_textfile
+} from "./chunk-SAHCLNNL.js";
+import {
+  genomic2gm
+} from "./chunk-HJ6L54YS.js";
+import {
+  Menu
+} from "./chunk-CXMZYVZT.js";
+import {
+  dofetch3,
+  guessSsmid,
+  ssmIdFieldsSeparator,
+  summarize_mclass
+} from "./chunk-KDKY7S5G.js";
+import {
+  icons
+} from "./chunk-73VHTIHG.js";
+import {
+  niceNumLabels
+} from "./chunk-GM6H3CUI.js";
+import {
+  bplen,
+  dt2label,
+  dtTerms,
+  dtcloss,
+  dtcnv,
+  dtdel,
+  dtfusionrna,
+  dtitd,
+  dtnloss,
+  dtsnvindel,
+  dtsv,
+  getColors,
+  gmmode,
+  mclass,
+  mds3tkMclass
+} from "./chunk-SOYDFNWV.js";
+import {
+  convertUnits
+} from "./chunk-TV74I3Y5.js";
+import {
+  arc_default
+} from "./chunk-CTVZMQ5J.js";
+import {
+  axisLeft,
+  axisRight
+} from "./chunk-LOZEKOES.js";
+import {
+  format,
+  linear
+} from "./chunk-733PDAIR.js";
+import {
+  select_default
+} from "./chunk-NDWTN4U5.js";
+import {
+  rgb,
+  rgb_default
+} from "./chunk-OMR2DT66.js";
+
+// mds3/itemtable.js
+async function itemtable(arg) {
+  if (arg.mlst.find((m) => m.dt != dtsnvindel && m.dt != dtfusionrna && m.dt != dtsv && m.dt != dtcnv)) {
+    throw "mlst[] contains unknown dt";
+  }
+  if (arg.mlst.length == 1) {
+    await itemtable_oneItem(arg);
+  } else {
+    await itemtable_multiItems(arg);
+  }
+  mayMoveTipDiv2left(arg);
+}
+function mayMoveTipDiv2left(arg) {
+  if (!arg.tipDiv) {
+    return;
+  }
+  const tableDoms = [];
+  for (const d of arg.div.selectAll("div").selectAll("table")) {
+    if (d) tableDoms.push(d);
+  }
+  if (!tableDoms.length) return;
+  let maxColumnCount = 0;
+  for (const table of tableDoms) {
+    const thead = table.firstChild;
+    if (thead.tagName != "THEAD") continue;
+    const tr = thead.firstChild;
+    if (tr.tagName != "TR") continue;
+    maxColumnCount = Math.max(maxColumnCount, tr.childNodes?.length);
+  }
+  if (maxColumnCount > 5) {
+    arg.tipDiv.style("left", "50px");
+  }
+}
+async function itemtable_oneItem(arg) {
+  const table = table2col({ holder: arg.div });
+  const m = arg.mlst[0];
+  if (m.dt == dtsnvindel) {
+    table_snvindel(arg, table);
+  } else if (m.dt == dtsv || m.dt == dtfusionrna) {
+    await table_svfusion(arg, table);
+  } else if (m.dt == dtcnv) {
+    table_cnv(arg, table);
+  } else {
+    throw "itemtable_oneItem: unknown dt";
+  }
+  arg.singleSampleDiv = table;
+  if (arg.tk.mds.variant2samples) {
+    if (m.occurrence) {
+      await init_sampletable(arg);
+    }
+  }
+}
+async function itemtable_multiItems(arg) {
+  const goBackButton = arg.div.append("div").style("margin", "10px").append("button").style("display", "none");
+  goBackButton.html("≪ Back to list").on("click", () => {
+    tableDiv.style("display", "");
+    goBackButton.style("display", "none");
+    singleVariantDiv.style("display", "none");
+  });
+  const singleVariantDiv = arg.div.append("div").style("display", "none");
+  const columns = [
+    {
+      label: `Click a ${dt2label[arg.mlst[0].dt]} to see details`,
+      fillCell: (td, i) => {
+        const m = arg.mlst[i];
+        if (m.dt == dtsnvindel) {
+          td.append("span").text(arg.tk.mnamegetter(m));
+          td.append("span").text(mclass[m.class].label).style("font-size", ".8em").style("margin-left", "10px").style("color", mclass[m.class].color);
+          td.append("span").text(`${m.chr}:${m.pos + 1}${m.ref ? ", " + m.ref + ">" + m.alt : ""}`).style("font-size", ".8em").style("margin-left", "10px");
+        } else if (m.dt == dtsv || m.dt == dtfusionrna) {
+          td.append("span").text(mclass[m.class].label).style("font-size", ".7em").style("margin-right", "8px");
+          printSvPair(m.pairlst[0], td);
+        } else if (m.dt == dtcnv) {
+          const cs = cnv2str(m, arg.tk);
+          td.html(cs.value + "  " + cs.pos);
+        } else {
+          td.text("error: unknown m.dt");
+        }
+      }
+    }
+  ];
+  const hasOccurrence = arg.mlst.some((i) => i.occurrence);
+  if (hasOccurrence) {
+    columns.push({ label: "Occurrence" });
+  }
+  let infoFields = null;
+  if (arg.tk.mds.bcf?.info) {
+    infoFields = [];
+    for (const k in arg.tk.mds.bcf.info) {
+      if (arg.tk.mds.bcf.info[k].categories) {
+        infoFields.push(k);
+        columns.push({ label: arg.tk.mds.bcf.info[k].name || k });
+      }
+    }
+    if (infoFields.length == 0) infoFields = null;
+  }
+  let numViewMode;
+  if (arg.tk.skewer) {
+    numViewMode = arg.tk.skewer.viewModes.find((i) => i.inuse && i.type == "numeric" && i.byAttribute != "occurrence");
+    if (numViewMode) {
+      columns.push({ label: numViewMode.label });
+    }
+  }
+  arg.mlst.sort((i, j) => i.__x - j.__x);
+  const rows = [];
+  for (const m of arg.mlst) {
+    const row = [{}];
+    if (hasOccurrence) {
+      row.push({ value: "occurrence" in m ? m.occurrence : "" });
+    }
+    if (infoFields) {
+      for (const k of infoFields) {
+        const v = m.info?.[k];
+        if (v == void 0) {
+          row.push({});
+        } else {
+          const o = arg.tk.mds.bcf.info[k].categories[v];
+          if (o?.color) {
+            row.push({ html: `<span style="background:${o.color}">&nbsp;&nbsp;</span> ${o.label || v}` });
+          } else {
+            row.push({ value: v });
+          }
+        }
+      }
+    }
+    if (numViewMode) {
+      row.push({ value: m.__value_use });
+    }
+    rows.push(row);
+  }
+  const tableDiv = arg.div.append("div");
+  renderTable({
+    div: tableDiv,
+    columns,
+    rows,
+    resize: true,
+    noButtonCallback: (i) => {
+      tableDiv.style("display", "none");
+      goBackButton.style("display", "");
+      singleVariantDiv.style("display", "").selectAll("*").remove();
+      const a2 = Object.assign({}, arg);
+      a2.mlst = [arg.mlst[i]];
+      a2.div = singleVariantDiv;
+      itemtable(a2);
+    },
+    singleMode: true,
+    noRadioBtn: true
+  });
+  if (!arg.doNotListSample4multim && arg.tk.mds.variant2samples) {
+    const totalOccurrence = arg.mlst.reduce((i, j) => i + (j.occurrence || 0), 0);
+    if (totalOccurrence) {
+      arg.div.append("div").style("margin-top", "10px").append("span").attr("class", "sja_clbtext").text("List all samples").on("click", async (event2) => {
+        event2.target.remove();
+        tableDiv.remove();
+        await init_sampletable(arg);
+        mayMoveTipDiv2left(arg);
+      });
+    }
+  }
+}
+async function table_snvindel({ mlst, tk, block }, table) {
+  const m = mlst[0];
+  {
+    const [td1, td2] = table.addRow();
+    td1.text(block.mclassOverride ? block.mclassOverride.className : "Consequence");
+    print_mname(td2, m);
+  }
+  {
+    const [td1, td2] = table.addRow();
+    td1.text(m.ref && m.alt ? "Mutation" : "Position");
+    print_snv(td2, m, tk, block);
+  }
+  if (m.occurrence > 1) {
+    const [td1, td2] = table.addRow();
+    td1.text("Occurrence");
+    td2.text(m.occurrence);
+  }
+  table_snvindel_mayInsertNumericValueRow(m, tk, table);
+  table_snvindel_mayInsertHtmlSections(m, tk, table);
+  table_snvindel_mayInsertLD(m, tk, table);
+  if (m.info) {
+    for (const key in m.info) {
+      if (key == "CSQ") {
+        continue;
+      }
+      const [td1, td2] = table.addRow();
+      td1.text(key).attr("data-testid", "sjpp-mds3tk-singlemtablerow4infokey");
+      const infoValue = m.info[key];
+      const infoField = tk.mds?.bcf?.info?.[key];
+      if (Array.isArray(infoValue)) {
+        for (const v of infoValue) {
+          renderInfoTd(m, infoField, v, td2, tk);
+        }
+      } else {
+        renderInfoTd(m, infoField, infoValue, td2, tk);
+      }
+      if (infoField?.Description) {
+        td2.append("span").style("margin-left", "10px").style("font-size", ".8em").style("opacity", 0.6).text(infoField.Description);
+      }
+    }
+  }
+}
+function table_snvindel_mayInsertNumericValueRow(m, tk, table) {
+  const currentMode = tk.skewer.viewModes.find((i) => i.inuse);
+  if (currentMode.type != "numeric" || currentMode.byAttribute == "occurrence") return;
+  if (currentMode.tooltipPrintValue) {
+    const tmp = currentMode.tooltipPrintValue(m);
+    if (Array.isArray(tmp)) {
+      for (const s of tmp) {
+        const [td12, td22] = table.addRow();
+        td12.text(s.k);
+        td22.text(s.v);
+      }
+    } else {
+      console.log("unknown return value");
+    }
+    return;
+  }
+  const [td1, td2] = table.addRow();
+  td1.text(currentMode.label);
+  td2.text(m.__value_missing ? "NA" : m.__value_use);
+}
+function table_snvindel_mayInsertHtmlSections(m, tk, table) {
+  if (!m.htmlSections) return;
+  if (!Array.isArray(m.htmlSections)) throw "htmlSections[] is not array";
+  for (const section of m.htmlSections) {
+    const [td1, td2] = table.addRow();
+    if (section.key && section.html) {
+      td1.text(section.key);
+      td2.html(section.html);
+    }
+  }
+}
+function renderInfoTd(m, infoField, infoValue, td, tk) {
+  if (!infoField) {
+    td.append("span").text(infoValue);
+    return;
+  }
+  if (infoField.urlBase) {
+    td.append("a").text(infoValue).attr("href", infoField.urlBase + infoValue).attr("target", "_blank");
+    return;
+  }
+  const color = infoField.categories?.[infoValue]?.color;
+  if (color) {
+    td.append("span").html("&nbsp;&nbsp;").style("background", color).style("margin-right", "5px");
+  }
+  td.append("span").text(infoField.categories?.[infoValue]?.label || infoValue);
+}
+function print_mname(div, m) {
+  div.append("span").text(m.mname);
+  div.append("span").style("margin-left", "5px").style("color", mclass[m.class].color).style("font-size", ".8em").text(mclass[m.class].label.toUpperCase());
+}
+function print_snv(holder, m, tk, block) {
+  const ssmNameDom = holder.append("span").text(`${m.chr}:${m.pos + 1} ${m.ref && m.alt ? m.ref + ">" + m.alt : ""}`);
+  const urlConfig = tk.mds.termdbConfig?.urlTemplates?.ssm || tk.mds.queries?.snvindel?.ssmUrl;
+  if (urlConfig) {
+    const separateUrls = makeSsmLink(urlConfig, m, ssmNameDom, block.genome.name);
+    if (separateUrls?.length) {
+      holder.append("span").style("margin-left", "10px").html(separateUrls.join(" "));
+    }
+  }
+}
+async function table_svfusion(arg, table) {
+  await makeSvgraph(
+    arg.mlst[0],
+    table.scrollDiv.insert("div", ":first-child"),
+    // insert to top
+    arg.block
+  );
+  {
+    const [c1, c2] = table.addRow();
+    c1.text("Data type");
+    c2.text(mclass[arg.mlst[0].class].label);
+  }
+  {
+    const [c1, c2] = table.addRow();
+    c1.text("Break points");
+    for (const pair of arg.mlst[0].pairlst) {
+      printSvPair(pair, c2.append("div"));
+    }
+  }
+}
+function table_cnv(arg, table) {
+  const cs = cnv2str(arg.mlst[0], arg.tk);
+  {
+    const [c1, c2] = table.addRow();
+    c1.text("Copy number change");
+    c2.html(cs.value);
+  }
+  {
+    const [c1, c2] = table.addRow();
+    c1.text("Position");
+    c2.html(cs.pos);
+  }
+}
+function cnv2str(m, tk) {
+  const cs = {};
+  if (Number.isFinite(m.value)) {
+    if (tk.cnv.colorScale) {
+      cs.value = `<span style="background:${tk.cnv.colorScale(m.value)}">&nbsp;&nbsp;</span> ${m.value}`;
+    } else {
+      cs.value = m.value;
+    }
+  } else {
+    cs.value = `<span style="background:${mclass[m.class].color}">&nbsp;&nbsp;</span> 
+			${tk.mds.termdbConfig?.mclass?.[m.class]?.label || mclass[m.class].label}`;
+  }
+  cs.pos = `${m.chr}:${m.start}-${m.stop} <span style="font-size:.8em">${bplen(m.stop - m.start)}</span>`;
+  return cs;
+}
+function printSvPair(pair, div) {
+  if (pair.a.name) div.append("span").text(pair.a.name).style("font-weight", "bold").style("margin-right", "5px");
+  div.append("span").text(
+    `${pair.a.chr}:${pair.a.pos + 1} ${pair.a.strand == "+" ? "forward" : "reverse"} > ${pair.b.chr}:${pair.b.pos + 1} ${pair.b.strand == "+" ? "forward" : "reverse"}`
+  );
+  if (pair.b.name) div.append("span").text(pair.b.name).style("font-weight", "bold").style("margin-left", "5px");
+}
+async function makeSvgraph(m, div, block) {
+  div.attr("data-testid", "sjpp-mds3tk-singlesvfusiongraph");
+  const wait = div.append("div").text("Loading...");
+  try {
+    if (!m.pairlst) throw ".pairlst[] missing";
+    const svpair = {
+      a: {
+        chr: m.pairlst[0].a.chr,
+        position: m.pairlst[0].a.pos,
+        strand: m.pairlst[0].a.strand
+      },
+      b: {
+        chr: m.pairlst[0].b.chr,
+        position: m.pairlst[0].b.pos,
+        strand: m.pairlst[0].b.strand
+      }
+    };
+    await getGm(svpair.a, block, m.pairlst[0].a.name);
+    await getGm(svpair.b, block, m.pairlst[0].b.name);
+    wait.remove();
+    const _ = await import("./svgraph-NZQ6Z4HS.js");
+    _.default({
+      pairlst: [svpair],
+      genome: block.genome,
+      holder: div
+    });
+  } catch (e) {
+    wait.text(e.message || e);
+  }
+}
+async function getGm(p, block, name) {
+  const d = await dofetch3("isoformbycoord", { body: { genome: block.genome.name, 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 };
+  }
+}
+function table_snvindel_mayInsertLD(m, tk, table) {
+  if (!tk.mds.queries?.ld) return;
+  const [td1, td2] = table.addRow();
+  td1.text("LD overlay");
+  const m0 = tk.mds.queries.ld.mOverlay?.m;
+  if (m0) {
+    const row = td2.append("div").style("margin-bottom", "5px");
+    if (m.ssm_id == m0.ssm_id) {
+      row.html(
+        tk.mds.queries.ld.mOverlay.ldtkname + " r<sup>2</sup> values against this variant are displayed on all the other variants."
+      );
+    } else {
+      let r2 = null;
+      for (const v of tk.mds.queries.ld.mOverlay.data || []) {
+        if (v.pos == m.pos && v.alleles == m.ref + "." + m.alt) {
+          r2 = v.r2;
+          break;
+        }
+      }
+      if (r2 == null) {
+        row.html("No r<sup>2</sup> value is found.");
+      } else {
+        row.html(tk.mds.queries.ld.mOverlay.ldtkname + " r<sup>2</sup> = " + r2);
+      }
+    }
+  }
+  td2.append("div").html("Click a button to overlay LD r<sup>2</sup> values against this variant:").style("font-size", ".8em").style("opacity", 0.5);
+  for (const o of tk.mds.queries.ld.tracks) {
+    const btn = td2.append("button").text(o.name);
+    if (m0 && m0.ssm_id == m.ssm_id) {
+      if (o.name == tk.mds.queries.ld.mOverlay.ldtkname) {
+        btn.property("disabled", true);
+        continue;
+      }
+    }
+    btn.on("click", () => {
+      tk.itemtip.hide();
+      tk.mds.queries.ld.mOverlay = {
+        ldtkname: o.name,
+        m: {
+          chr: m.chr,
+          pos: m.pos,
+          ref: m.ref,
+          alt: m.alt,
+          ssm_id: m.ssm_id
+          // required for highlighting
+        }
+      };
+      tk.load();
+    });
+  }
+}
+
+// mds3/sampletable.js
+async function init_sampletable(arg) {
+  const wait = arg.div.append("div").text("Loading...").style("padding", "10px").style("color", "#8AB1D4").style("font-size", "1.25em").style("font-weight", "bold");
+  arg.tid2value_orig = /* @__PURE__ */ new Set();
+  if (arg.tid2value) Object.keys(arg.tid2value).forEach(arg.tid2value_orig.add, arg.tid2value_orig);
+  try {
+    arg.querytype = arg.tk.mds.variant2samples.type_samples;
+    const out = await arg.tk.mds.variant2samples.get(arg);
+    await displaySampleTable(out.samples, arg);
+    wait.remove();
+  } catch (e) {
+    wait.text("Error: " + (e.message || e));
+    if (e.stack) console.log(e.stack);
+  }
+}
+async function displaySampleTable(samples, args) {
+  if (samples.length == 1) {
+    return await make_singleSampleTable(samples[0], args);
+  }
+  const [columns, rows] = await samples2columnsRows(samples, args.tk);
+  const params = { rows, columns, div: args.div, resize: rows.length > 10, dataTestId: "sjpp_mds3tk_sampletable" };
+  params.columnButtons = [];
+  if (args.tk.mds.queries?.singleSampleMutation) {
+    const width = window.innerWidth;
+    const height = screen.height;
+    const colButton = {
+      text: "Disco",
+      dataTestId: "sja_sample_table_disco_button",
+      callback: async (event2, i) => {
+        args.tk.itemtip.hide();
+        args.tk.menutip.hide();
+        let thisMutation;
+        if (samples[i].ssm_id_lst?.[0]) {
+          thisMutation = (args.tk.skewer.rawmlst || args.tk.custom_variants).find(
+            (m) => m.ssm_id == samples[i].ssm_id_lst[0]
+          );
+        }
+        await createDiscoInSandbox(args.tk, args.block, samples[i], thisMutation);
+      }
+    };
+    params.columnButtons.push(colButton);
+  }
+  if (args.tk.mds.queries?.singleSampleGenomeQuantification) {
+    for (const k in args.tk.mds.queries.singleSampleGenomeQuantification) {
+      const btn = {
+        text: k,
+        dataTestId: `${k}_button`,
+        callback: async (event2, i) => {
+          const sandbox = newSandboxDiv(args.tk.newChartHolder || args.block.holder0);
+          sandbox.header.text(samples[i].sample_id);
+          await (await import("./plot.ssgq-WR3HFXR4.js")).plotSingleSampleGenomeQuantification(
+            args.tk.mds,
+            args.tk.mds.label,
+            k,
+            samples[i],
+            sandbox.body.append("div").style("margin", "20px"),
+            args.block.genome,
+            args.block.usegm?.name
+          );
+        }
+      };
+      params.columnButtons.push(btn);
+    }
+  }
+  if (args.tk.allow2selectSamples) {
+    params.buttons = [
+      {
+        text: args.tk.allow2selectSamples.buttonText,
+        class: args.tk.allow2selectSamples.class,
+        callback: (sampleIdxLst) => {
+          feedSample2selectCallback(args.tk, args.block, samples, sampleIdxLst);
+          args.tk.itemtip.hide();
+          args.tk.menutip.hide();
+        }
+      }
+    ];
+  }
+  return renderTable(params);
+}
+async function feedSample2selectCallback(tk, block, _samples, sampleIdxLst) {
+  const s = [..._samples];
+  const samples = sampleIdxLst.map((i) => s[i]);
+  tk.allow2selectSamples.callback({
+    samples: await tk.mds.termdb.vocabApi.convertSampleId(samples, tk.allow2selectSamples.attributes),
+    source: "Samples with " + block2source(block)
+  });
+}
+async function make_singleSampleTable(s, arg) {
+  const table = arg.singleSampleDiv || table2col({ holder: arg.div });
+  if (s.sample_id) {
+    const [cell1, cell2] = table.addRow();
+    cell1.text(arg.tk.mds.termdbConfig?.lollipop?.sample || "Sample");
+    let m;
+    if (s.ssm_id_lst?.[0]) {
+      m = arg.tk.skewer.rawmlst.find((i) => i.ssm_id == s.ssm_id_lst[0]);
+    }
+    printSampleName(s, arg.tk, cell2, arg.block, m);
+  }
+  if ("caseIsOpenAccess" in s) {
+    const [cell1, cell2] = table.addRow();
+    cell1.text("Access");
+    cell2.text(s.caseIsOpenAccess ? "Open" : "Controlled");
+  }
+  if (arg.tk.mds.variant2samples.twLst) {
+    for (const tw of arg.tk.mds.variant2samples.twLst) {
+      const [cell1, cell2] = table.addRow();
+      cell1.text(tw.term.name).style("text-overflow", "ellipsis");
+      cell2.style("text-overflow", "ellipsis");
+      if (tw.term.id in s) {
+        if (Array.isArray(s[tw.term.id])) {
+          cell2.html(value2urlsOrText(s[tw.term.id], tw));
+        } else {
+          const v = twDisplayValueFromSample(s, tw);
+          cell2.html(value2urlsOrText(v, tw));
+        }
+      }
+    }
+  }
+  if (s.ssmid2format) {
+    for (const ssmid of s.ssm_id_lst) {
+      if (s.ssm_id_lst.length > 1) {
+        const [td1, td] = table.addRow();
+        td.style("padding-top", "20px");
+        const m = arg.tk.skewer.rawmlst.find((i) => i.ssm_id == ssmid);
+        if (m) {
+          if (m.dt == dtsnvindel) {
+            print_snv(td, m, arg.tk, arg.block);
+          } else if (m.dt == dtsv || m.dt == dtfusionrna) {
+            printSvPair(m.pairlst[0], td);
+          } else {
+            td.text(ssmid);
+          }
+        } else {
+          td.text(ssmid);
+        }
+      } else {
+      }
+      for (const formatkey in s.ssmid2format[ssmid]) {
+        const value = s.ssmid2format[ssmid][formatkey];
+        const [t1, t2] = table.addRow();
+        const fobj = arg.tk.mds?.bcf?.format?.[formatkey];
+        t1.text(fobj?.Description || formatkey).attr("data-testid", "sjpp-mds3tk-singlemtablerow4formatkey").attr("__key__", formatkey);
+        t2.html(printFormat(fobj, value));
+      }
+    }
+  }
+}
+function twDisplayValueFromSample(s, tw) {
+  if (!(tw.term.id in s)) return "";
+  const v = s[tw.term.id];
+  if (tw.term.values?.[v]?.label) return tw.term.values[v].label;
+  const vc = tw.term.valueConversion;
+  if (vc) return convertUnits(v, vc.fromUnit, vc.toUnit, vc.scaleFactor);
+  return v;
+}
+function printSampleName(sample, tk, div, block, thisMutation) {
+  const temp = tk.mds.termdbConfig?.urlTemplates?.sample;
+  if (temp) {
+    const a = div.append("a");
+    a.attr("href", temp.base + (sample[temp.namekey] || sample.sample_id));
+    a.attr("target", "_blank");
+    a.text(sample.sample_id);
+    a.style("word-break", "break-word");
+  } else {
+    div.append("span").attr("class", "pp_mds3_singleSampleNameSpan").text(sample.sample_id);
+  }
+  const extraRow = div.append("div");
+  if (tk.allow2selectSamples) {
+    const t = tk.allow2selectSamples.buttonText;
+    const btn = extraRow.append("button").attr("data-testid", "sjpp-mds3tk-selectsamplebtn").style("margin-right", "10px").text(t.endsWith("s") ? t.substring(0, t.length - 1) : t).on("click", () => {
+      feedSample2selectCallback(tk, block, [sample], [0]);
+      tk.itemtip.hide();
+      tk.menutip.hide();
+    });
+    if (tk.allow2selectSamples.class) btn.attr("class", tk.allow2selectSamples.class);
+  }
+  if (tk.mds.queries?.singleSampleMutation) {
+    extraRow.append("button").style("margin-right", "10px").text("Disco plot").attr("data-testid", "proteinpaint_disc_table_disco_button").on("click", async () => {
+      tk.itemtip.hide();
+      await createDiscoInSandbox(tk, block, sample, thisMutation);
+    });
+  }
+  if (tk.mds.queries?.singleSampleGenomeQuantification) {
+    for (const k in tk.mds.queries.singleSampleGenomeQuantification) {
+      extraRow.append("button").text(k).on("click", async () => {
+        const sandbox = newSandboxDiv(tk.newChartHolder || block.holder0);
+        sandbox.header.text(sample.sample_id);
+        await (await import("./plot.ssgq-WR3HFXR4.js")).plotSingleSampleGenomeQuantification(
+          tk.mds,
+          tk.mds.label,
+          k,
+          sample,
+          sandbox.body.append("div").style("margin", "20px"),
+          block.genome,
+          block.usegm?.name
+          /* to pass current gene name to launch ssgb at that gene
+          do not use thisMutation.gene, as "gene" is not guaranteed attribute on mutations
+          */
+        );
+      });
+    }
+  }
+}
+async function createDiscoInSandbox(tk, block, sample, thisMutation) {
+  const sandbox = newSandboxDiv(tk.newChartHolder || block.holder0);
+  const headerTexts = [sample.sample_id];
+  if (thisMutation) {
+    headerTexts.push(", with ");
+    if (block.usegm) {
+      headerTexts.push(block.usegm.name);
+    } else {
+      headerTexts.push(thisMutation.isoform);
+    }
+    headerTexts.push(" " + thisMutation.mname);
+  }
+  sandbox.header.text(headerTexts.join(""));
+  try {
+    ;
+    (await import("./plot.disco-477IKREB.js")).default(
+      tk.mds.termdbConfig,
+      tk.mds.label,
+      sample,
+      sandbox.body,
+      block.genome,
+      {
+        downloadImgName: headerTexts.join("") + " Disco"
+        // file name of svg downloaded from disco
+      }
+    );
+  } catch (e) {
+    sandbox.body.append("div").text("Error: " + (e.message || e));
+    if (e.stack) console.log(e.stack);
+  }
+}
+async function samples2columnsRows(samples, tk) {
+  const has_caseAccess = samples.some((i) => "caseIsOpenAccess" in i), has_ssm = samples.some((i) => i.ssm_id) || samples.some((i) => i.ssm_id_lst), has_format = samples.some((i) => i.ssmid2format) && tk.mds?.bcf?.format;
+  const displayedFormatKeySet = /* @__PURE__ */ new Set();
+  const columns = [{ label: tk.mds.termdbConfig?.lollipop?.sample || "Sample" }], rows = [];
+  if (has_caseAccess) {
+    columns.push({ label: "Access" });
+  }
+  if (tk.mds.variant2samples.twLst) {
+    for (const tw of tk.mds.variant2samples.twLst) {
+      const cell = { label: tw.term.name };
+      columns.push(cell);
+    }
+  }
+  if (has_ssm) {
+    columns.push({
+      label: "Mutations",
+      isSsm: true
+      // flag for text file downloader to do detect and do special treatment on this field
+    });
+  }
+  if (has_format) {
+    for (const s of samples) {
+      if (!s.ssmid2format) continue;
+      for (const sm in s.ssmid2format) {
+        for (const k in s.ssmid2format[sm]) displayedFormatKeySet.add(k);
+      }
+    }
+    for (const f in tk.mds.bcf.format) {
+      if (!displayedFormatKeySet.has(f)) continue;
+      const fobj = tk.mds.bcf.format[f];
+      columns.push({
+        label: fobj.Description || f
+      });
+    }
+  }
+  for (const sample of samples) {
+    const row = [{ value: sample.sample_id }];
+    let ssm_id_lst = sample.ssm_id_lst;
+    if (!ssm_id_lst && sample.ssm_id) ssm_id_lst = [sample.ssm_id];
+    {
+      const temp = tk.mds.termdbConfig?.urlTemplates?.sample;
+      if (temp) {
+        row[0].url = temp.base + (sample[temp.namekey] || sample.sample_id);
+      }
+    }
+    if (has_caseAccess) {
+      row.push({ value: sample.caseIsOpenAccess ? "Open" : "Controlled" });
+    }
+    if (tk.mds.variant2samples.twLst) {
+      for (const tw of tk.mds.variant2samples.twLst) {
+        const v = twDisplayValueFromSample(sample, tw);
+        const v2 = value2urlsOrText(v, tw);
+        if (tw.baseURL || tw.pmidOrDoi) {
+          row.push({ html: v2 });
+        } else {
+          row.push({ value: v });
+        }
+      }
+    }
+    if (has_ssm) {
+      if (ssm_id_lst) {
+        const htmls = [];
+        for (const ssm_id of ssm_id_lst) {
+          const m = findMbyId(ssm_id, tk);
+          const oneHtml = [];
+          if (m) {
+            let showClass;
+            if (m.dt == dtsnvindel) {
+              if (tk.mds.queries && tk.mds.queries.snvindel && tk.mds.queries.snvindel.url) {
+                oneHtml.push(`<a href=${tk.mds.queries.snvindel.url.base + m.ssm_id} target=_blank>${m.mname}</a>`);
+              } else {
+                oneHtml.push(m.mname);
+              }
+              showClass = true;
+            } else if (m.dt == dtsv || m.dt == dtfusionrna) {
+              const p = sample._pairlst?.[0] || m.pairlst[0];
+              oneHtml.push(
+                `${p.a.name || ""} ${p.a.chr}:${p.a.pos} ${p.a.strand == "+" ? "forward" : "reverse"} > ${p.b.name || ""} ${p.b.chr}:${p.b.pos} ${p.b.strand == "+" ? "forward" : "reverse"}`
+              );
+              showClass = true;
+            } else if (m.dt == dtcnv) {
+              const v = cnv2str(m, tk);
+              oneHtml.push(v.value + " " + v.pos);
+              showClass = Number.isFinite(m.value);
+            } else {
+              throw "unknown dt";
+            }
+            if (showClass) {
+              oneHtml.push(
+                `<span style="color:${rgb(mclass[m.class].color).darker()};font-size:0.8em;">${mclass[m.class].label}</span>`
+              );
+            }
+            htmls.push(`<span style="white-space:nowrap">${oneHtml.join(" ")}</span>`);
+          } else {
+            htmls.push(ssm_id + "?");
+          }
+        }
+        row.push({ html: htmls.join("<br>") });
+      } else {
+        row.push({ value: "" });
+      }
+    }
+    if (has_format) {
+      if (!ssm_id_lst) throw "ssm_id_lst missing, cannot show format";
+      for (const fkey in tk.mds.bcf.format) {
+        if (!displayedFormatKeySet.has(fkey)) continue;
+        if (!sample.ssmid2format) {
+          row.push({ value: "" });
+          continue;
+        }
+        const fobj = tk.mds.bcf.format[fkey];
+        const htmls = [];
+        for (const ssmid of ssm_id_lst) {
+          const value = sample.ssmid2format?.[ssmid]?.[fkey];
+          if (value == void 0) {
+            htmls.push("&nbsp;");
+          } else {
+            htmls.push(printFormat(fobj, value));
+          }
+        }
+        row.push({ html: `<span style="white-space:nowrap">${htmls.join("<br>")}</span>` });
+      }
+    }
+    rows.push(row);
+  }
+  return [columns, rows];
+}
+function value2urlsOrText(v, tw) {
+  if (tw.baseURL) {
+    if (Array.isArray(v)) return v.map((i) => `<a href=${tw.baseURL + i} target=_blank>${i}</a>`).join("<br>");
+    return `<a href=${tw.baseURL + v} target=_blank>${v}</a>`;
+  }
+  if (tw.pmidOrDoi) {
+    const h = [];
+    for (const i of Array.isArray(v) ? v : [v]) {
+      if (i.startsWith("doi: ")) {
+        h.push(`<a href=https://doi.org/${i.slice(5)} target=_blank>${i}</a>`);
+      } else {
+        h.push(`<a href=https://pubmed.ncbi.nlm.nih.gov/${i} target=_blank>${i}</a>`);
+      }
+    }
+    return h.join("<br>");
+  }
+  if (Array.isArray(v)) return v.join("<br>");
+  return v;
+}
+function findMbyId(str, tk) {
+  const lst = tk.skewer?.rawmlst || tk.custom_variants;
+  if (lst) {
+    const m = lst.find((i) => i.ssm_id == str);
+    if (m) return m;
+  }
+  if (tk.cnv) {
+    if (tk.cnv.cnvLst) {
+      const m = tk.cnv.cnvLst.find((i) => i.ssm_id == str);
+      if (m) return m;
+    } else {
+      const m = guessSsmid(str);
+      if (m.dt == dtcnv) {
+        return {
+          dt: dtcnv,
+          chr: m.l[0],
+          start: m.l[1],
+          stop: m.l[2],
+          class: m.l[3],
+          value: m.l[4]
+        };
+      }
+    }
+  }
+  return null;
+}
+function printFormat(fobj, value) {
+  if (fobj && value && fobj.Number == "R" && fobj.Type == "Integer") {
+    const lst = value.split(",").map(Number);
+    if (lst.length == 2) {
+      const [ref, alt] = lst;
+      if (ref >= 0 && alt >= 0 && ref + alt > 0) {
+        return `${fillbar(null, { f: alt / (alt + ref) })} <span style="font-size:.8em">${alt}/${alt + ref}</span>`;
+      }
+    }
+  }
+  return value;
+}
+function block2source(b) {
+  if (b.gmmode == "genomic") {
+    const r = b.rglst[0];
+    return "mutations from " + r.chr + ":" + r.start + "-" + r.stop;
+  }
+  if (b.usegm) return "mutations in " + b.usegm.name;
+  return "mutations";
+}
+
+// mds3/clickVariant.js
+var minoccur4sunburst = 10;
+async function click_variant(d, tk, block, tippos, eventTarget) {
+  try {
+    if (tk.click_snvindel) {
+      tk.skewer.hlssmid = new Set(d.mlst.map((i) => i.ssm_id));
+      mayHighlightDiskBySsmid(tk);
+      tk.click_snvindel(d.mlst[0]);
+      return;
+    }
+    if ("occurrence" in d && d.occurrence >= minoccur4sunburst && tk.mds.variant2samples && tk.mds.variant2samples.sunburst_twLst) {
+      await click2sunburst(d, tk, block, tippos);
+      return;
+    }
+    await variant_details({ mlst: d.mlst, tk, block, tippos });
+  } catch (e) {
+    block.error(e.message || e);
+    if (e.stack) console.log(e.stack);
+  }
+}
+async function click2sunburst(d, tk, block, tippos) {
+  tk.glider.style("cursor", "wait");
+  const data = await tk.mds.variant2samples.get({
+    mlst: d.mlst,
+    querytype: tk.mds.variant2samples.type_sunburst
+  });
+  tk.glider.style("cursor", "auto");
+  if (!dataGood4sunburst(data)) {
+    await variant_details({ mlst: d.mlst, tk, block, tippos });
+    return;
+  }
+  const arg = {
+    nodes: data.nodes,
+    occurrence: d.occurrence,
+    boxyoff: tk.yoff,
+    boxheight: Math.min(800, tk.height),
+    // guard against very tall track
+    boxwidth: block.width,
+    svgheight: Number.parseFloat(block.svg.attr("height")),
+    g: tk.skewer.g.append("g"),
+    pica: tk.pica,
+    click_listbutton: (x, y) => {
+      variant_details({ mlst: d.mlst, tk, block, tippos });
+    },
+    click_ring: async (event2, d2) => {
+      tk.itemtip.clear();
+      const param = {
+        mlst: d.mlst,
+        tk,
+        block,
+        div: tk.itemtip.d,
+        tid2value: {}
+      };
+      param.tid2value[d2.data.id0] = d2.data.v0;
+      if (d2.data.id1) param.tid2value[d2.data.id1] = d2.data.v1;
+      if (d2.data.id2) param.tid2value[d2.data.id2] = d2.data.v2;
+      param.mlst = d.mlst.map((m) => {
+        if (tk.mds.variant2samples.variantkey == "ssm_id") {
+          return { ssm_id: m.ssm_id, occurrence: 0 };
+        }
+        throw "unknown variant2samples.variantkey";
+      });
+      param.mlst[0].occurrence = d2.value;
+      const x = event2.clientX;
+      const y = event2.clientY;
+      await init_sampletable(param);
+      tk.itemtip.show2(x, y);
+    }
+  };
+  if (d.aa) {
+    arg.cx = d.aa.x;
+    arg.cy = skewer_sety(d, tk) + d.yoffset * (tk.skewer.pointup ? -1 : 1);
+  } else {
+    arg.cx = d.x;
+    arg.cy = d.y + (tk.skewer.pointup ? 1 : -1) * tk.skewer.stem1 / 2;
+  }
+  if (d.mlst.length == 1) {
+    arg.chartlabel = d.mlst[0].mname;
+  } else {
+    const mnameSet = new Set(d.mlst.map((i) => i.mname));
+    if (mnameSet.size == 1) {
+      arg.chartlabel = [...mnameSet][0];
+    } else {
+      arg.chartlabel = d.mlst.reduce((i, j) => j.occurrence > i.occurrence ? j : i).mname + " etc";
+    }
+  }
+  const _ = await import("./sunburst-ZDE5Q2SJ.js");
+  _.default(arg);
+}
+function dataGood4sunburst(data) {
+  if (!Array.isArray(data.nodes)) throw "nodes not array";
+  if (data.nodes.length == 0) throw "nodes empty array";
+  if (data.nodes.length == 1) return false;
+  for (let i = 1; i < data.nodes.length; i++) {
+    const n = data.nodes[i];
+    if (!n.name) throw "node name missing";
+    if (!Number.isInteger(n.cohortsize)) {
+    }
+  }
+  return true;
+}
+async function variant_details(arg) {
+  arg.tk.itemtip.clear().show(arg.tippos.left - 10, arg.tippos.top - 10);
+  arg.div = arg.tk.itemtip.d;
+  arg.tipDiv = arg.tk.itemtip.d;
+  await itemtable(arg);
+}
+
+// mds3/skewer.render.shapes.ts
+function renderSkewerShapes(tk, skewer, shapeG) {
+  shapeG.filter((d) => d.dt == dtsnvindel || d.dt == dtsv || d.dt == dtfusionrna).append("path").attr("d", (d) => shapes[d.shape].calculatePath(getPathDimensions(d.shape, d.radius, skewer.pointup))).attr("fill", (d) => !shapes[d.shape].isFilled ? "none" : d.mlst?.[0] ? tk.color4disc(d.mlst[0]) : tk.color4disc(d)).attr(
+    "stroke",
+    (d) => (d.dt == dtfusionrna || d.dt == dtsv) && d?.mlst[0] ? tk.color4disc(d.mlst[0]) : shapes[d.shape].isFilled ? "white" : d.mlst?.[0] ? tk.color4disc(d.mlst[0]) : tk.color4disc(d)
+  );
+  const defs = shapeG.append("defs").selectAll("clipPath").data(shapeG.data()).enter().append("clipPath").attr(
+    "id",
+    (d) => `clip-path-${d?.mlst ? `${d.mlst[0].mname}-${d.mlst[0].__x}-${d.yoffset}` : `${d.mname}-${d.__x}-${d._y}`}`
+  );
+  defs.each(function(d) {
+    const { width, height } = getPathDimensions(d.shape, d.radius, skewer.pointup);
+    if (!width || !height) return;
+    select_default(this).append("rect").attr("x", d.useNterm != shapes[d.shape].isFilled ? -(width / 2) : 0).attr("y", -(height / 2)).attr("width", d.useNterm != shapes[d.shape].isFilled ? width / 2 : width).attr("height", height);
+  });
+  shapeG.filter((d) => d.dt == dtfusionrna || d.dt == dtsv).append("g").attr(
+    "clip-path",
+    (d) => `url(#clip-path-${d?.mlst ? `${d.mlst[0].mname}-${d.mlst[0].__x}-${d.yoffset}` : `${d.mname}-${d.__x}-${d._y}`}`
+  ).append("path").attr("d", (d) => shapes[d.shape].calculatePath(getPathDimensions(d.shape, d.radius, skewer.pointup))).attr("fill", (d) => shapes[d.shape].isFilled ? "white" : tk.color4disc(d.mlst[0])).attr("stroke", "none");
+}
+function renderShapeKick(skewer, elem) {
+  const kick = elem.append("path").attr("d", (d) => {
+    if (!d.shape) d.shape = d.groups[0].shape;
+    const radius = d.radius * 1.01 || d.maxradius + 2;
+    return shapes[d.shape].calculatePath(getPathDimensions(d.shape, radius, skewer.pointup));
+  }).attr("stroke-width", 1.75);
+  return kick;
+}
+function getPathDimensions(key, radius, pointup = true) {
+  switch (key) {
+    case "filledCircle":
+      return { radius: radius * 0.95 };
+    case "emptyCircle":
+      return { radius };
+    case "filledVerticalRectangle":
+      return { width: radius * 1.5, height: radius * 2.1 };
+    case "emptyVerticalRectangle":
+      return { width: radius * 1.4, height: radius * 2 };
+    case "filledTriangle":
+      return { width: radius * 2.1, height: radius * 2.1, isUp: pointup };
+    case "emptyTriangle":
+      return { width: radius * 2, height: radius * 2, isUp: pointup };
+    case "filledSquare":
+      return { width: radius * 1.7, height: radius * 1.7 };
+    case "emptySquare":
+      return { width: radius * 1.7, height: radius * 1.7 };
+    default:
+      throw "Invalid shape key. Add shape [getPathDimensions() skewer.render.shapes.ts]";
+  }
+}
+function setNumBaseline(key, pointup) {
+  if (key.includes("Triangle")) {
+    if (pointup) return "central";
+    else return `text-after-edge`;
+  } else return "";
+}
+
+// mds3/skewer.render.js
+var modefold = 0;
+var modeshow = 1;
+var middlealignshift = 0.3;
+var disclabelspacing = 1;
+var textlensf = 0.6;
+function skewer_make(tk, block) {
+  const ss = tk.skewer;
+  for (const d of ss.data) {
+    d.x0 = d.x;
+    if (d.xoffset != void 0) {
+      d.x = d.x0 + d.xoffset;
+    }
+    for (const g of d.groups) {
+      g.aa = d;
+    }
+  }
+  const dotwidth = Math.max(14, block.width / 110);
+  let mdc = 0;
+  for (const d of ss.data) {
+    for (const g of d.groups) {
+      mdc = Math.max(mdc, g.occurrence);
+    }
+  }
+  let mrd = 0;
+  const w = Math.pow(dotwidth / 2, 2) * Math.PI;
+  if (mdc <= 10) mrd = w * mdc * 0.9;
+  else if (mdc <= 100) mrd = w * 10;
+  else if (mdc <= 1e3) mrd = w * 14;
+  else mrd = w * 20;
+  const sf_discradius = linear().domain([1, mdc * 0.5, mdc * 0.6, mdc * 0.7, mdc * 0.8, mdc]).range([w, w + (mrd - w) * 0.8, w + (mrd - w) * 0.85, w + (mrd - w) * 0.9, w + (mrd - w) * 0.95, mrd]);
+  let globalmaxradius = dotwidth / 2;
+  ss.maxheight = 0;
+  for (const d of ss.data) {
+    if (d.showmode == void 0) d.showmode = modefold;
+    if (d.slabelrotate == void 0) d.slabelrotate = false;
+    d.maxradius = 0;
+    d.maxrimwidth = 0;
+    d.width = 0;
+    d.slabelwidth = 0;
+    for (const r of d.groups) {
+      if (r.occurrence <= 1) {
+        r.radius = dotwidth / 2;
+      } else {
+        const digc = r.occurrence.toString().length;
+        r.radius = Math.max(Math.sqrt(sf_discradius(r.occurrence) / Math.PI), digc * 5);
+      }
+      d.maxradius = Math.max(d.maxradius, r.radius);
+      globalmaxradius = Math.max(globalmaxradius, r.radius);
+      r.rimwidth = r.rim1count + r.rim2count == 0 ? 0 : Math.max(2, r.radius / 6);
+      d.maxrimwidth = Math.max(d.maxrimwidth, r.rimwidth);
+    }
+    let totalheight = 0;
+    for (const r of d.groups) {
+      r.yoffset = totalheight + r.radius + r.rimwidth;
+      totalheight += (r.radius + r.rimwidth) * 2;
+    }
+    ss.maxheight = Math.max(ss.maxheight, totalheight);
+  }
+  if (!tk.shapes) {
+    if (!tk.shapeBy) {
+      tk.shapes = {};
+      Object.keys(mclass).forEach((v) => tk.shapes[v] = "filledCircle");
+    }
+  }
+  ss.selection = ss.g.selectAll().data(ss.data).enter().append("g").attr("class", "sja_skg").each(function(d) {
+    d.skewer = this;
+  });
+  const discg = ss.selection.selectAll().data((d) => d.groups).enter().append("g").attr(
+    "transform",
+    (d) => "translate(0," + (d.aa.showmode == modefold ? 0 : d.yoffset * (tk.skewer.pointup ? -1 : 1)) + ")"
+  ).attr("class", "sja_aa_discg").each(function(d) {
+    d.g = this;
+    if (!d.shape) {
+      d.shape = tk.shapes[d.mlst[0].class];
+    }
+    if (!d.shape.includes("Circle")) {
+      renderSkewerShapes(tk, ss, select_default(this));
+    } else {
+      const discdot = select_default(this).append("circle");
+      discdot.filter((d2) => d2.dt == dtsnvindel || d2.dt == dtsv || d2.dt == dtfusionrna).attr("fill", (d2) => !shapes[d2.shape].isFilled ? "white" : tk.color4disc(d2.mlst[0])).attr("stroke", (d2) => !shapes[d2.shape].isFilled ? tk.color4disc(d2.mlst[0]) : "white").attr("r", (d2) => d2.radius - 0.5);
+      select_default(this).filter((d2) => d2.dt == dtfusionrna || d2.dt == dtsv).append("path").attr("fill", (d2) => !shapes[d2.shape].isFilled ? tk.color4disc(d2.mlst[0]) : "white").attr("stroke", "none").attr(
+        "d",
+        (d2) => arc_default()({
+          innerRadius: 0,
+          outerRadius: d2.radius - 2,
+          /**** Always show the colored area on the correct side ****
+           * Preserves showing the colored:white areas regardless if
+           * the shape is filled or not
+           */
+          startAngle: d2.useNterm == shapes[d2.shape].isFilled ? 0 : Math.PI,
+          endAngle: d2.useNterm == shapes[d2.shape].isFilled ? Math.PI : Math.PI * 2
+        })
+      );
+    }
+  });
+  const textslc = discg.filter((d) => d.occurrence > 1).append("text").text((d) => d.occurrence).attr("class", "sja_aa_discnum").attr("fill-opacity", (d) => d.aa.showmode == modefold ? 0 : 1).attr("stroke-opacity", (d) => d.aa.showmode == modefold ? 0 : 1).attr("dominant-baseline", (d) => tk.shapes ? setNumBaseline(d.shape, tk.skewer.pointup) : "").attr("text-anchor", "middle").each((d) => {
+    const s = d.radius * 1.5;
+    d.discnumfontsize = Math.min(s / (d.occurrence.toString().length * textlensf), s);
+  }).attr("font-size", (d) => d.discnumfontsize).attr("y", (d) => d.discnumfontsize * middlealignshift);
+  textslc.filter((d) => d.dt == dtsnvindel).attr("fill", (d) => tk.shapes && !shapes[d.shape].isFilled ? "black" : "white");
+  textslc.filter((d) => d.dt == dtsv || d.dt == dtfusionrna).attr("stroke", (d) => tk.color4disc(d.mlst[0])).attr("stroke-width", 0.8).attr("font-weight", "bold").attr("fill", "white");
+  const textlab = discg.append("text").text((d) => d.mnameCompact || tk.mnamegetter(d.mlst[0])).attr("font-size", (d) => {
+    d._labfontsize = Math.max(12, d.radius * 1.2);
+    return d._labfontsize;
+  }).each(function(d) {
+    const lw = this.getBBox().width;
+    d._label_width = lw;
+    if (d.aa.groups.length == 1) {
+      d.aa.slabelrotate = true;
+      d.aa.slabelwidth = lw;
+      ss.maxheight = Math.max(ss.maxheight, (d.radius + d.rimwidth) * 2 + 2 + lw);
+    }
+  }).attr("fill", (d) => tk.color4disc(d.mlst[0])).attr("x", (d) => d.radius + d.rimwidth + 1).attr("y", (d) => d._labfontsize * middlealignshift).classed("sja_aa_disclabel", true).attr("fill-opacity", (d) => d.aa.showmode == modefold ? 0 : 1).attr("transform", "scale(1) rotate(0)").on("mousedown", (event2) => {
+    event2.stopPropagation();
+  }).on("click", (event2, d) => {
+    fold_glyph([d.aa], tk);
+    unfold_update(tk, block);
+  }).on("mouseover", (event2, d) => {
+    event2.target.setAttribute("font-size", d._labfontsize * 1.1);
+    showHoverTipOnDisk(event2, d, tk);
+  }).on("mouseout", (event2, d) => {
+    event2.target.setAttribute("font-size", d._labfontsize);
+    tk.hovertip.hide();
+  });
+  ss.hlBoxG = discg.append("g");
+  for (const d of ss.data) {
+    let leftw = 0, rightw = 0;
+    for (const g of d.groups) {
+      leftw = Math.max(leftw, g.radius + g.rimwidth);
+      rightw = Math.max(rightw, g.radius + g.rimwidth + disclabelspacing + g._label_width);
+    }
+    d.width = leftw + rightw;
+  }
+  let kick;
+  if (tk.shapes) {
+    kick = renderShapeKick(ss, discg);
+  } else {
+    kick = discg.append("circle").attr("r", (d) => d.radius - 0.5);
+  }
+  kick.attr("stroke", (d) => tk.color4disc(d.mlst[0])).classed("sja_aa_disckick", true).attr("fill", "white").attr("fill-opacity", 0).attr("stroke-opacity", 0).on("mousedown", (event2) => {
+    event2.stopPropagation();
+  }).on("mouseover", (event2, d) => {
+    showHoverTipOnDisk(event2, d, tk);
+    if (tk.disc_mouseover) {
+      tk.disc_mouseover(d, event2.target);
+    }
+  }).on("mouseout", (event2, d) => {
+    tk.hovertip.hide();
+    if (tk.disc_mouseout) {
+      tk.disc_mouseout(d);
+    }
+  }).on("click", async (event2, d) => {
+    click_variant(d, tk, block, event2.target.getBoundingClientRect(), event2.target);
+  });
+  const rimfunc = arc_default().innerRadius((d) => d.radius).outerRadius((d) => d.radius + d.rimwidth).startAngle(0).endAngle((d) => {
+    d.rim1_startangle = Math.PI * 2 * d.rim1count / d.occurrence;
+    return d.rim1_startangle;
+  });
+  discg.filter((d) => d.rim1count > 0).append("path").attr("d", rimfunc).attr("fill", (d) => tk.color4disc(d.mlst[0])).attr("class", "sja_aa_discrim").attr("fill-opacity", 0);
+  const rimfunc2 = arc_default().innerRadius((d) => d.radius + 0.5).outerRadius((d) => d.radius + 0.5 + d.rimwidth).startAngle((d) => d.rim1_startangle).endAngle((d) => d.rim1_startangle + Math.PI * 2 * d.rim2count / d.occurrence);
+  discg.filter((d) => d.rim2count > 0).append("path").attr("d", rimfunc2).attr("stroke", (d) => tk.color4disc(d.mlst[0])).attr("fill", "none").attr("class", "sja_aa_discrim").attr("stroke-opacity", 0);
+  {
+    let lapcount = 0;
+    let lastx = 0;
+    for (const d of ss.data) {
+      if (d.x - d.maxradius - d.maxrimwidth < lastx) {
+        lapcount++;
+      }
+      lastx = Math.max(lastx, d.x + d.width - d.maxradius - d.maxrimwidth);
+    }
+    ss.stem1 = lapcount == 0 ? 0 : dotwidth;
+    ss.stem2 = linear().domain([0, 1, ss.data.length]).range([0, dotwidth, dotwidth * 3])(lapcount);
+  }
+  const hbaseline = dotwidth * 0.7;
+  let maxm = 0;
+  for (const d of ss.data) {
+    for (const g of d.groups) {
+      maxm = Math.max(maxm, g.occurrence);
+    }
+  }
+  ss.stem3 = Math.max(2, hbaseline + dotwidth * Math.min(5, maxm));
+  let foldedKick;
+  if (tk.shapes) {
+    foldedKick = renderShapeKick(ss, ss.selection);
+    foldedKick.attr(
+      "transform",
+      (d) => `translate(0, ${(tk.skewer.pointup ? -1 : 1) * d.maxradius})
+			scale(${d.showmode == modefold ? "1,1" : "0.01,0.01"})`
+    );
+  } else {
+    foldedKick = ss.selection.append("circle").attr("r", (d) => d.maxradius + 1).attr("cy", (d) => (tk.skewer.pointup ? -1 : 1) * d.maxradius).attr("transform", (d) => `scale(${d.showmode == modefold ? "1,1" : "0.01,0.01"})`);
+  }
+  foldedKick.attr("class", "sja_aa_skkick").attr("fill", "white").attr("fill-opacity", 0).attr("stroke", "none").on("mouseover", (event2, d) => {
+    let cumh = 0;
+    let boxw = 0;
+    const hpad = 5;
+    const tiph = tk.skewer.pointup ? 7 : 14;
+    for (const g of d.groups) {
+      g.pica_fontsize = Math.max(11, g.radius);
+      cumh += g.pica_fontsize + 1;
+      tk.pica.g.append("text").text((g.mnameCompact || g.mlst[0].mname) + (g.occurrence > 1 ? " x" + g.occurrence : "")).attr("font-size", g.pica_fontsize).each(function() {
+        boxw = Math.max(boxw, this.getBBox().width);
+      }).remove();
+    }
+    boxw += hpad * 2;
+    const boxh = cumh + 5;
+    tk.pica.g.append("rect").attr("y", tk.skewer.pointup ? -boxh : 0).attr("width", boxw).attr("height", boxh).attr("fill", "white").attr("fill-opacity", 0.8).attr("stroke", "#ccc").attr("shape-rendering", "crispEdges");
+    cumh = 0;
+    const _g = tk.pica.g.selectAll().data(d.groups).enter().append("g").attr("transform", (g, i) => {
+      cumh += g.pica_fontsize + 1;
+      return "translate(" + hpad + "," + cumh * (tk.skewer.pointup ? -1 : 1) + ")";
+    });
+    _g.append("text").text((g) => g.mnameCompact || g.mlst[0].mname).attr("font-size", (g) => g.pica_fontsize).each(function(g) {
+      g.pica_mlabelwidth = this.getBBox().width;
+    }).attr("fill", (d2) => tk.color4disc(d2.mlst[0])).attr("dominant-baseline", tk.skewer.pointup ? "hanging" : "auto");
+    const firstlabw = d.groups[0].pica_mlabelwidth;
+    tk.pica.x = d.x - hpad - firstlabw / 2;
+    tk.pica.y = d.y + (tk.skewer.pointup ? -1 : 1) * (d.maxradius * 2 + tiph + 2);
+    tk.pica.g.attr("transform", "translate(" + tk.pica.x + "," + tk.pica.y + ")");
+    _g.filter((g) => g.occurrence > 1).append("text").text((g) => "x" + g.occurrence).attr("x", (g) => g.pica_mlabelwidth + 5).attr("font-size", (g) => g.pica_fontsize).attr("dominant-baseline", tk.skewer.pointup ? "hanging" : "auto").attr("fill", "#9e9e9e");
+    const handle = tk.pica.g.append("g").attr("transform", "translate(" + (hpad + firstlabw / 2) + "," + (tk.skewer.pointup ? 1 : -1) + ")");
+    handle.append("line").attr("y2", (tk.skewer.pointup ? 1 : -1) * tiph).attr("stroke", "#858585").attr("shape-rendering", "crispEdges");
+    handle.append("line").attr("x1", -1).attr("x2", -1).attr("y2", (tk.skewer.pointup ? 1 : -1) * tiph).attr("stroke", "white").attr("shape-rendering", "crispEdges");
+    handle.append("line").attr("x1", 1).attr("x2", 1).attr("y2", (tk.skewer.pointup ? 1 : -1) * tiph).attr("stroke", "white").attr("shape-rendering", "crispEdges");
+  }).on("mouseout", (event2, d) => {
+    tk.pica.g.selectAll("*").remove();
+  }).on("click", (event2, d) => {
+    tk.pica.g.selectAll("*").remove();
+    unfold_glyph([d], tk, block);
+  });
+  let mm = 0;
+  for (const d of ss.data) {
+    mm = Math.max(mm, d.occurrence);
+  }
+  const sf_foldyoff = linear().domain([1, mm]).range([hbaseline, ss.stem3 - globalmaxradius]);
+  ss.selection.attr("transform", (d) => {
+    d.foldyoffset = sf_foldyoff(d.occurrence);
+    d.y = skewer_sety(d, tk);
+    return "translate(" + d.x + "," + d.y + ")";
+  });
+  ss.selection.append("path").attr("class", "sja_aa_stem").attr("d", (d) => skewer_setstem(d, tk)).attr("stroke", (d) => tk.color4disc(d.groups[0].mlst[0])).attr("fill", "none");
+  const mgsk = ss.selection.filter((d) => d.groups.length > 1);
+  mgsk.append("rect").attr("class", "sja_aa_ssk_bg").attr("shape-rendering", "crispEdges").attr("fill-opacity", 0).attr("height", ss.stem1).attr("fill", (d) => tk.color4disc(d.groups[0].mlst[0])).attr("width", (d) => {
+    d.ssk_width = Math.max(d.occurrence.toString().length * 8 + 6, 2 * (d.maxradius + d.maxrimwidth));
+    return d.ssk_width;
+  }).attr("x", (d) => -d.ssk_width / 2);
+  mgsk.append("text").attr("class", "sja_aa_ssk_text").attr("fill", "white").attr("fill-opacity", 0).attr("font-weight", "bold").attr("text-anchor", "middle").attr("dominant-baseline", "central").text((d) => d.occurrence).each((d) => {
+    d.ssk_fontsize = Math.min(ss.stem1, d.ssk_width / (d.occurrence.toString().length * textlensf));
+  }).attr("font-size", (d) => d.ssk_fontsize);
+  mgsk.append("rect").attr("class", "sja_aa_ssk_kick").attr("fill", "white").attr("fill-opacity", 0).attr("stroke", "none").attr("height", ss.stem1).attr("x", (d) => -d.ssk_width / 2).attr("width", (d) => d.ssk_width).on("mouseover", (event2, d) => {
+    const p = select_default(event2.target.parentNode);
+    p.selectAll(".sja_aa_disckick").transition().attr("stroke-opacity", 1);
+    p.select(".sja_aa_ssk_bg").transition().attr("fill-opacity", 1).attr("stroke-opacity", 1);
+    p.select(".sja_aa_ssk_text").transition().attr("fill-opacity", 1);
+  }).on("mouseout", function(event2, d) {
+    const p = select_default(event2.target.parentNode);
+    p.selectAll(".sja_aa_disckick").transition().attr("stroke-opacity", 0);
+    p.select(".sja_aa_ssk_bg").transition().attr("fill-opacity", 0).attr("stroke-opacity", 0);
+    p.select(".sja_aa_ssk_text").transition().attr("fill-opacity", 0);
+  }).on("click", async (event2, d) => {
+    click_variant(d, tk, block, event2.target.getBoundingClientRect(), null, event2.target);
+  });
+}
+function skewer_sety(d, tk) {
+  if (tk.skewer.pointup) {
+    if (d.showmode == modefold) {
+      return tk.skewer.maxheight + tk.skewer.stem1 + tk.skewer.stem2 + tk.skewer.stem3 - d.foldyoffset;
+    }
+    return tk.skewer.maxheight;
+  }
+  if (d.showmode == modefold) return d.foldyoffset;
+  return tk.skewer.stem1 + tk.skewer.stem2 + tk.skewer.stem3;
+}
+function skewer_setstem(d, tk) {
+  if (tk.skewer.pointup) {
+    if (d.showmode == modefold) {
+      return "M0,0v0l0,0v" + d.foldyoffset;
+    }
+    return "M0,0v" + tk.skewer.stem1 + "l" + (d.x0 - d.x) + "," + tk.skewer.stem2 + "v" + tk.skewer.stem3;
+  }
+  if (d.showmode == modefold) {
+    return "M0,0v0l0,0v-" + d.foldyoffset;
+  }
+  return "M0,0v-" + tk.skewer.stem1 + "l" + (d.x0 - d.x) + ",-" + tk.skewer.stem2 + "v-" + tk.skewer.stem3;
+}
+function settle_glyph(tk, block) {
+  if (tk.skewer.data.length == 0) return;
+  const x1 = 0;
+  const x2 = block.width;
+  let sumwidth = 0;
+  const allinview = [];
+  const beyondviewitems = [];
+  for (const d of tk.skewer.data) {
+    if (d.x0 < x1 || d.x0 > x2) {
+      delete d.xoffset;
+      beyondviewitems.push(d);
+    } else {
+      sumwidth += d.slabelrotate ? (d.groups[0].radius + d.groups[0].rimwidth) * 2 : d.width;
+      allinview.push(d);
+    }
+  }
+  fold_glyph(beyondviewitems, tk);
+  let expandlst = [];
+  const foldlst = [];
+  if (sumwidth < x2 - x1) {
+    expandlst = allinview;
+  } else {
+    allinview.sort((a, b) => {
+      if (b.occurrence == a.occurrence) {
+        if (b.groups.length == a.groups.length) {
+          return Math.abs(a.x0 * 2 - x1 - x2) - Math.abs(b.x0 * 2 - x1 - x2);
+        } else {
+          return b.groups.length - a.groups.length;
+        }
+      }
+      return b.occurrence - a.occurrence;
+    });
+    let width = 0;
+    let allowpx = (x2 - x1) * 0.8;
+    let stop = false;
+    for (const d of allinview) {
+      if (stop) {
+        delete d.xoffset;
+        foldlst.push(d);
+        d.showmode = modefold;
+      } else {
+        if (width + d.width < allowpx) {
+          expandlst.push(d);
+          width += d.width;
+        } else {
+          stop = true;
+          delete d.xoffset;
+          foldlst.push(d);
+          d.showmode = modefold;
+        }
+      }
+    }
+  }
+  fold_glyph(foldlst, tk);
+  unfold_glyph(expandlst, tk, block);
+}
+function unfold_glyph(newlst, tk, block) {
+  const dur = 1e3;
+  const expanded = /* @__PURE__ */ new Set();
+  const folded = /* @__PURE__ */ new Set();
+  for (const d of newlst) {
+    if (d.showmode == modeshow) {
+      expanded.add(d.x0);
+    } else {
+      d.showmode = modeshow;
+      folded.add(d.x0);
+      d.y = skewer_sety(d, tk);
+    }
+  }
+  if (expanded.size) {
+    const set = tk.skewer.selection.filter((d) => expanded.has(d.x0));
+    set.selectAll(".sja_aa_discrim").attr("fill-opacity", 1).attr("stroke-opacity", 1);
+  }
+  if (folded.size) {
+    const set = tk.skewer.selection.filter((d) => folded.has(d.x0));
+    set.transition().duration(dur).attr("transform", (d) => "translate(" + d.x + "," + d.y + ")");
+    set.selectAll(".sja_aa_discg").transition().duration(dur).attr("transform", (d) => {
+      d.y = d.yoffset * (tk.skewer.pointup ? -1 : 1);
+      return "translate(0," + d.y + ")";
+    });
+    set.selectAll(".sja_aa_disckick").transition().duration(dur).attr("transform", "scale(1)").on("end", () => {
+      set.selectAll(".sja_aa_ssk_kick").attr("transform", "scale(1)").attr("y", tk.skewer.pointup ? 0 : -tk.skewer.stem1);
+      set.selectAll(".sja_aa_disckick").classed("sjpp-active", true);
+    });
+    set.selectAll(".sja_aa_discnum").transition().duration(dur).attr("fill-opacity", 1).attr("stroke-opacity", 1);
+    set.filter((d) => d.groups.length > 1).selectAll(".sja_aa_disclabel").transition().duration(dur).attr("fill-opacity", 1).attr("transform", "scale(1)");
+    set.selectAll(".sja_aa_discrim").transition().duration(dur).attr("fill-opacity", 1).attr("stroke-opacity", 1);
+    set.selectAll(".sja_aa_ssk_bg").attr("transform", "scale(1)").attr("y", tk.skewer.pointup ? 0 : -tk.skewer.stem1);
+    set.selectAll(".sja_aa_ssk_text").attr("transform", "scale(1)").attr("y", (tk.skewer.pointup ? 1 : -1) * tk.skewer.stem1 / 2);
+    set.selectAll(".sja_aa_skkick").transition().duration(0).attr(
+      "transform",
+      (d) => `${d.shape && !d.shape.includes("Circle") ? `translate(0, ${(tk.skewer.pointup ? -1 : 1) * d.maxradius})` : ""} scale(0.01, 0.01)`
+      // safari fix
+    ).on("end", () => {
+      set.selectAll(".sja_aa_skkick").classed("sjpp-active", false);
+    });
+    let counter = 0;
+    set.selectAll(".sja_aa_stem").transition().duration(dur).attr("d", (d) => skewer_setstem(d, tk)).each(() => ++counter).on("end", () => {
+      if (!--counter) {
+        unfold_update(tk, block);
+      }
+    });
+  } else {
+    unfold_update(tk, block);
+  }
+}
+function unfold_update(tk, block) {
+  const dur = 1e3;
+  const alllst = [];
+  const hash = /* @__PURE__ */ new Set();
+  const x1 = 0;
+  const x2 = block.width;
+  for (const d of tk.skewer.data) {
+    if (d.x0 < x1 || d.x0 > x2) continue;
+    if (d.showmode == modeshow) {
+      d.x = d.x0;
+      alllst.push(d);
+      hash.add(d.x0);
+    }
+  }
+  if (alllst.length == 0) {
+    return;
+  }
+  horiplace(alllst, tk, block);
+  for (const d of alllst) {
+    d.xoffset = d.x - d.x0;
+  }
+  for (let i = 0; i < alllst.length; i++) {
+    const d = alllst[i];
+    if (d.groups.length > 1) continue;
+    const disc = d.groups[0];
+    if (tk.slabel_forcerotate) {
+      d.slabelrotate = true;
+    } else {
+      const next = alllst[i + 1];
+      const rightx = next ? next.x - next.maxradius - next.maxrimwidth : x2;
+      d.slabelrotate = rightx - d.x - disc.radius - disc.rimwidth - 1 < d.slabelwidth;
+    }
+    d.width = (disc.radius + disc.rimwidth) * 2 + (d.slabelrotate ? 0 : 2 + d.slabelwidth);
+  }
+  const set = tk.skewer.selection.filter((d) => hash.has(d.x0));
+  set.transition().duration(dur).attr("transform", (d) => "translate(" + d.x + "," + d.y + ")");
+  set.selectAll(".sja_aa_stem").transition().duration(dur).attr("d", (d) => skewer_setstem(d, tk));
+  set.filter((d) => d.groups.length == 1).selectAll(".sja_aa_disclabel").transition().duration(dur).attr("fill-opacity", 1).attr(
+    "transform",
+    (d) => "scale(1) rotate(" + (d.aa.slabelrotate ? (tk.skewer.pointup ? "-" : "") + "90" : "0") + ")"
+  );
+  tk.slabel_forcerotate = false;
+}
+function horiplace(items, tk, block) {
+  const xoffset0 = 0;
+  const x2 = block.width;
+  let xoffset = xoffset0;
+  let overlap = false;
+  for (const i of items) {
+    if (i.x0 < xoffset0 || i.x0 > x2) continue;
+    if (i.groups.length == 1) {
+      i.slabelrotate = true;
+      const disc = i.groups[0];
+      i.width = (disc.radius + disc.rimwidth) * 2;
+    }
+    const x = i.x - i.maxradius - i.maxrimwidth;
+    if (x < xoffset) {
+      overlap = true;
+    }
+    if (x + i.width > x2) {
+      overlap = true;
+    }
+    xoffset = Math.max(xoffset, x + i.width);
+  }
+  if (!overlap) {
+    return false;
+  }
+  xoffset = xoffset0;
+  for (const i of items) {
+    if (i.x0 < xoffset0 || i.x0 > x2) continue;
+    i.x = xoffset + i.maxradius + i.maxrimwidth;
+    xoffset += i.width;
+  }
+  horiplace0(items, block.width);
+}
+function horiplace0(items, allwidth) {
+  for (let i = 0; i < items.length; i++) {
+    if (items[i].x0 < 0) continue;
+    if (items[i].x0 > allwidth) break;
+    while (1) {
+      let currsum = 0, newsum = 0;
+      for (let j = i; j < items.length; j++) {
+        const t = items[j];
+        if (t.x0 > allwidth) {
+          return;
+        }
+        currsum += Math.abs(t.x - t.x0);
+        t.x++;
+        newsum += Math.abs(t.x - t.x0);
+      }
+      if (items[i].x >= items[i].x0) {
+        for (let j = i; j < items.length; j++) {
+          items[j].x--;
+        }
+        break;
+      }
+      const z = items[items.length - 1];
+      if (z.x + z.width / 2 >= allwidth) {
+        return;
+      }
+      if (newsum <= currsum) {
+      } else {
+        for (let j = i; j < items.length; j++) {
+          if (items[j].x0 > allwidth) {
+            break;
+          }
+          items[j].x--;
+        }
+        break;
+      }
+    }
+  }
+}
+function fold_glyph(lst, tk) {
+  if (lst.length == 0) return;
+  const dur = 1e3;
+  const hash = /* @__PURE__ */ new Set();
+  for (const d of lst) {
+    d.x = d.x0;
+    hash.add(d.x0);
+    d.showmode = modefold;
+    d.y = skewer_sety(d, tk);
+  }
+  const set = tk.skewer.selection.filter((d) => hash.has(d.x0));
+  set.transition().duration(dur).attr("transform", (d) => "translate(" + d.x + "," + d.y + ")");
+  set.selectAll(".sja_aa_stem").transition().duration(dur).attr("d", (d) => skewer_setstem(d, tk));
+  set.selectAll(".sja_aa_discg").transition().duration(dur).attr("transform", (d) => "translate(0," + (tk.skewer.pointup ? "-" : "") + d.aa.maxradius + ")");
+  set.selectAll(".sja_aa_disckick").transition().duration(0).attr("transform", "scale(0)").on("end", () => {
+    set.selectAll(".sja_aa_disckick").classed("sjpp-active", false);
+  });
+  set.selectAll(".sja_aa_discnum").transition().duration(dur).attr("fill-opacity", 0).attr("stroke-opacity", 0);
+  set.selectAll(".sja_aa_disclabel").transition().duration(dur).attr("fill-opacity", 0).attr("transform", "scale(0)");
+  set.selectAll(".sja_aa_discrim").transition().duration(dur).attr("fill-opacity", 0).attr("stroke-opacity", 0);
+  set.selectAll(".sja_aa_ssk_kick").attr("transform", "scale(0)");
+  set.selectAll(".sja_aa_ssk_bg").attr("transform", "scale(0)");
+  set.selectAll(".sja_aa_ssk_text").attr("transform", "scale(0)");
+  set.selectAll(".sja_aa_skkick").transition().duration(dur).attr("transform", (d) => `${d.shape ? `translate(0, ${(tk.skewer.pointup ? -1 : 1) * d.maxradius})` : ""} scale(1)`).on("end", () => {
+    set.selectAll(".sja_aa_skkick").classed("sjpp-active", true);
+  });
+}
+function mayHighlightDiskBySsmid(tk) {
+  tk.skewer.hlBoxG.selectAll("*").remove();
+  if (!tk.skewer.hlssmid) return;
+  tk.skewer.hlBoxG.filter((g) => {
+    if (g.mlst) {
+      return g.mlst.find((m) => tk.skewer.hlssmid.has(m.ssm_id));
+    }
+    return tk.skewer.hlssmid.has(g.ssm_id);
+  }).append("rect").attr("x", (g) => -g.radius).attr("y", (g) => -g.radius).attr("width", (g) => g.radius * 2).attr("height", (g) => g.radius * 2).attr("stroke", tk.skewer.hlBoxColor).attr("stroke-width", (g) => g.radius > 10 ? 1.5 : 1).attr("fill", "none").attr("class", "sja_mds3_skewer_ssmhlbox");
+}
+function showHoverTipOnDisk(event2, d, tk) {
+  tk.hovertip.clear().show(event2.clientX, event2.clientY);
+  if (!d.mlst?.[0]) {
+    tk.hovertip.d.append("div").text("d.mlst[] missing or blank");
+    return;
+  }
+  const m = mclass[d.mlst[0]?.class] || { color: "black", label: "_unknown" };
+  tk.hovertip.d.append("div").style("font-size", ".9em").html(`<span style="background:${m.color}">&nbsp;&nbsp;</span> ${m.label}`);
+  if (d.mlst[0].occurrence) {
+    const c = d.mlst.reduce((t, i) => t + i.occurrence, 0);
+    tk.hovertip.d.append("div").text(`${c} sample${c > 1 ? "s" : ""}`);
+  }
+  if (d.mlst.length > 1) {
+    tk.hovertip.d.append("div").text(`${d.mlst.length} ${d.mlst[0].dt == dtsnvindel ? "variants" : "alterations"}`);
+  }
+}
+
+// mds3/datagroup.js
+var minbpwidth = 4;
+function make_datagroup(tk, rawmlst, block) {
+  mlst_pretreat(rawmlst, tk, block);
+  const x2mlst = /* @__PURE__ */ new Map();
+  for (const m of rawmlst) {
+    if (m.__x == void 0) continue;
+    if (!x2mlst.has(m.__x)) {
+      x2mlst.set(m.__x, []);
+    }
+    x2mlst.get(m.__x).push(m);
+  }
+  const datagroup = [];
+  if (block.exonsf >= minbpwidth) {
+    for (const [x, mlst] of x2mlst) {
+      datagroup.push({
+        chr: mlst[0].chr,
+        pos: mlst[0].pos,
+        mlst,
+        x
+      });
+    }
+  } else {
+    if (block.usegm && block.usegm.coding && block.gmmode != gmmode.genomic) {
+      const aa2mlst = /* @__PURE__ */ new Map();
+      for (const [x, mlst] of x2mlst) {
+        if (mlst[0].chr != block.usegm.chr) {
+          continue;
+        }
+        let aapos = void 0;
+        for (const m of mlst) {
+          if (Number.isFinite(m.aapos)) aapos = m.aapos;
+        }
+        if (aapos == void 0) {
+          aapos = genomic2gm(mlst[0].pos, block.usegm).aapos;
+        }
+        if (aapos == void 0) {
+          console.error("data item cannot map to aaposition");
+          console.log(mlst[0]);
+          continue;
+        }
+        x2mlst.delete(x);
+        if (!aa2mlst.has(aapos)) {
+          aa2mlst.set(aapos, []);
+        }
+        let notmet = true;
+        for (const lst of aa2mlst.get(aapos)) {
+          if (Math.abs(lst[0].__x - mlst[0].__x) <= block.exonsf * 3) {
+            for (const m of mlst) {
+              lst.push(m);
+            }
+            notmet = false;
+            break;
+          }
+        }
+        if (notmet) {
+          aa2mlst.get(aapos).push(mlst);
+        }
+      }
+      for (const llst of aa2mlst.values()) {
+        for (const mlst of llst) {
+          let m = null;
+          for (const m2 of mlst) {
+            if (Number.isFinite(m2.rnapos)) m = m2;
+          }
+          if (m == null) {
+            console.log("trying to map mlst to codon, but no rnapos found");
+            for (const m2 of mlst) {
+              console.log(m2);
+            }
+            continue;
+          }
+          datagroup.push({
+            chr: mlst[0].chr,
+            pos: m.pos,
+            mlst,
+            x: mlst[0].__x
+          });
+        }
+      }
+    }
+    const pxbin = [];
+    const binpx = 2;
+    for (const [x, mlst] of x2mlst) {
+      const i = Math.floor(x / binpx);
+      if (!pxbin[i]) {
+        pxbin[i] = [];
+      }
+      pxbin[i] = [...pxbin[i], ...mlst];
+    }
+    for (const mlst of pxbin) {
+      if (!mlst) continue;
+      const xsum = mlst.reduce((i, j) => i + j.__x, 0);
+      datagroup.push({
+        isbin: true,
+        chr: mlst[0].chr,
+        pos: mlst[0].pos,
+        mlst,
+        x: xsum / mlst.length
+      });
+    }
+  }
+  datagroup.sort((a, b) => a.x - b.x);
+  return datagroup;
+}
+function mlst_pretreat(rawmlst, tk, block) {
+  let nogenomicpos = 0, outofcds = 0, nochr = 0;
+  const unmapped = [];
+  const usemlst = [];
+  for (const m of rawmlst) {
+    delete m.__x;
+    if (block.gmmode == gmmode.protein && block.usegm.codingstart && block.usegm.codingstop) {
+      if (m.pos < block.usegm.codingstart || m.pos > block.usegm.codingstop) {
+        outofcds++;
+        continue;
+      }
+    }
+    if (!m.chr) {
+      nochr++;
+      continue;
+    }
+    if (!Number.isInteger(m.pos)) {
+      nogenomicpos++;
+      continue;
+    }
+    const hits = block.seekcoord(m.chr, m.pos);
+    if (hits.length == 0) {
+      unmapped.push(m);
+      continue;
+    }
+    if (hits.length == 1) {
+      m.__x = hits[0].x;
+    } else {
+      m.__x = hits[0].x;
+    }
+    if (m.__x < -1 || m.__x > block.width + 1) {
+      continue;
+    }
+    usemlst.push(m);
+  }
+  if (nogenomicpos + nochr > 0) {
+    block.tkerror(tk, nogenomicpos + nochr + " items have no chromosome or genomic position");
+  }
+  if (unmapped.length) {
+    console.error(unmapped.length + " items not mapped to any region");
+    for (const m of unmapped) console.log(m);
+  }
+  dsqueryresult_snvindelfusionitd(usemlst, tk, block);
+}
+function dsqueryresult_snvindelfusionitd(lst, tk, block) {
+  for (const m of lst) {
+    if (block.usegm) {
+      const t = genomic2gm(m.pos, block.usegm);
+      m.rnapos = t.rnapos;
+      m.aapos = t.aapos;
+    }
+    if (m.dt == dtsnvindel) {
+      continue;
+    }
+    if (m.dt == dtsv || m.dt == dtfusionrna) {
+      if (m.pairlstIdx == 0) {
+        m.useNterm = true;
+      } else {
+        m.useNterm = false;
+      }
+      continue;
+    }
+    throw "unknown dt: " + m.dt;
+  }
+}
+
+// mds3/leftlabel.js
+var labyspace = 5;
+async function make_leftlabels(data, tk, block) {
+  let laby = 0;
+  makeVariantLabel(data, tk, block, laby);
+  if (tk.leftlabels.doms.variants) {
+    laby += labyspace + block.labelfontsize;
+  }
+  if ("sampleTotalNumber" in data || tk.leftlabels.doms.samples) {
+    const _ = await import("./leftlabel.sample-BSDNBLN4.js");
+    _.makeSampleLabel(data, tk, block, laby);
+    laby += labyspace + block.labelfontsize;
+    if (tk.filterObj) {
+      _.makeSampleFilterLabel(data, tk, block, laby);
+    }
+    if (tk.leftlabels.doms.filterObj) {
+      laby += labyspace + block.labelfontsize;
+    }
+  }
+  if (tk.showCloseLeftlabel) {
+    if (!tk.leftlabels.doms.close) {
+      tk.leftlabels.doms.close = makelabel(tk, block, laby).text("Close").on("click", () => {
+        for (const [i, t] of block.tklst.entries()) {
+          if (t.tkid == tk.tkid) {
+            block.tk_remove(i);
+          }
+        }
+        tk.onClose?.();
+      });
+    }
+    laby += labyspace + block.labelfontsize;
+  }
+  tk.leftlabels.laby = laby;
+  positionLeftlabelg(tk, block);
+  setLeftlabelsMaxWidth(tk);
+  tk.subtk2height.leftlabels = laby + 20;
+}
+function setLeftlabelsMaxWidth(tk) {
+  tk.leftlabels.maxwidth = tk.tklabel.node().getBBox().width;
+  for (const k in tk.leftlabels.doms) {
+    tk.leftlabels.maxwidth = Math.max(tk.leftlabels.maxwidth, tk.leftlabels.doms[k].node().getBBox().width);
+  }
+}
+function positionLeftlabelg(tk, block) {
+  if (tk.leftlabels.laby == 0) {
+    return;
+  }
+  tk.leftlabels.xoff = 0;
+  if (tk.skewer) {
+    const nm = tk.skewer.viewModes.find((i) => i.inuse);
+    if (nm.type == "numeric") {
+      const lly = tk.leftlabels.laby + labyspace + block.labelfontsize;
+      if (lly > nm.toplabelheight + 5) {
+        tk.leftlabels.xoff = nm.axisWidth;
+      }
+    }
+  }
+  tk.leftlabels.g.transition().attr("transform", `translate(-${tk.leftlabels.xoff},${labyspace + block.labelfontsize})`);
+}
+function makelabel(tk, block, y) {
+  const text = tk.leftlabels.g.append("text").attr("font-size", block.labelfontsize).attr("y", block.labelfontsize / 2 + y).attr("text-anchor", "end").attr("dominant-baseline", "central").attr("class", "sja_clbtext2").attr("fill", "black").attr("x", block.tkleftlabel_xshift).attr("tabindex", 0).on("keydown", function(event2) {
+    if (event2.target != textElem) return;
+    if (event2.key == "Enter") textElem.dispatchEvent(new Event("click"));
+  });
+  const textElem = text.node();
+  return text;
+}
+
+// mds3/numericmode.js
+var disclabelspacing2 = 1;
+var middlealignshift2 = 0.3;
+var labyspace2 = 5;
+var clustercrowdlimit = 7;
+var maxclusterwidth = 100;
+var stemColor = "#ededed";
+var defaultLabel = "Numeric value";
+function renderNumericMode(nm, data, tk, block) {
+  const datagroup = make_datagroup(tk, data.skewer || tk.skewer.rawmlst, block).filter(
+    (g) => g.x >= 0 && g.x <= block.width
+  );
+  nm.data = datagroup;
+  if (!nm.axisg) nm.axisg = tk.gleft.append("g");
+  if (!nm.axisheight) nm.axisheight = 150;
+  clearTk(tk);
+  numeric_make(nm, tk, block);
+  mayHighlightByLDoverlay(tk);
+  return nm.toplabelheight + nm.maxradius + nm.axisheight + nm.maxradius + nm.stem1 + nm.stem2 + nm.stem3 + nm.bottomlabelheight;
+}
+function clearTk(tk) {
+  tk.skewer.g.selectAll("*").remove();
+  if (tk.skewer.nmg) tk.skewer.nmg.selectAll("*").remove();
+}
+function numeric_make(nm, tk, block) {
+  if (!nm.axisSetting) {
+    nm.axisSetting = { auto: 1 };
+  }
+  const data = nm.data;
+  for (const d of data) {
+    d.x0 = d.x;
+    if (d.xoffset != void 0) {
+      d.x = d.x0 + d.xoffset;
+    }
+  }
+  const dotwidth = Math.max(14, block.width / 110);
+  nm.dotwidth = dotwidth;
+  nm.maxradius = 0;
+  for (const d of data) {
+    for (const m of d.mlst) {
+      m.radius = dotwidth / 2;
+      nm.maxradius = Math.max(m.radius, nm.maxradius);
+      m.rimwidth = 0;
+      m.aa = d;
+    }
+  }
+  const showstem = adjustview(data, nm, tk, block);
+  setup_axis_scale(data, nm, tk);
+  const numscale = linear().domain([nm.minvalue, nm.maxvalue]).range([0, nm.axisheight]);
+  for (const d of data) {
+    for (const m of d.mlst) {
+      if (m.__value_missing) {
+        m._y = 0;
+      } else {
+        if (m.__value_use < nm.minvalue) {
+          m._y = 0;
+        } else if (m.__value_use > nm.maxvalue) {
+          m._y = nm.axisheight;
+        } else {
+          m._y = numscale(m.__value_use);
+        }
+      }
+    }
+  }
+  if (showstem) {
+    nm.stem1 = 5;
+    nm.stem2 = 20;
+    nm.stem3 = 10;
+  } else {
+    nm.stem1 = 0;
+    nm.stem2 = 0;
+    nm.stem3 = 0;
+  }
+  for (const d of data) {
+    for (const m of d.mlst) {
+      tk.glider.append("text").text(tk.mnamegetter(m)).attr("font-size", m.radius * 2 - 2).each(function() {
+        m.labwidth = this.getBBox().width;
+      }).remove();
+    }
+  }
+  for (const d of data) {
+    for (const m of d.mlst) {
+      delete m.labattop;
+      delete m.labatbottom;
+    }
+  }
+  if (!tk.skewer.hideDotLabels) {
+    if (showstem) {
+      for (const d of data) {
+        if (d.mlst.length == 1) {
+          const m = d.mlst[0];
+          m.labattop = true;
+        } else {
+          if ((d.width - d.fixedgew) / (d.mlst.length - 1) < clustercrowdlimit) {
+          } else {
+            for (const m of d.mlst) {
+              m.labattop = true;
+            }
+          }
+        }
+      }
+    } else {
+      verticallabplace(data);
+    }
+  }
+  nm.toplabelheight = 0;
+  nm.bottomlabelheight = 0;
+  if (nm.showsamplebar || nm.showgenotypebyvalue) {
+    for (const d of data) {
+      for (const m of d.mlst) {
+        nm.toplabelheight = Math.max(nm.toplabelheight, m.labwidth);
+      }
+    }
+  } else {
+    for (const d of data) {
+      for (const m of d.mlst) {
+        if (m.labattop) {
+          nm.toplabelheight = Math.max(nm.toplabelheight, m._y + m.labwidth - nm.axisheight);
+        } else if (m.labatbottom) {
+          nm.bottomlabelheight = Math.max(nm.bottomlabelheight, m.labwidth - m._y);
+        }
+        if (m.shapeCircle) {
+          m.shape = "emptyCircle";
+          delete m.shapeCircle;
+        } else if (m.shapeTriangle) {
+          m.shape = "filledTriangle";
+          delete m.shapeTriangle;
+        } else if (!m.shape) m.shape = "filledCircle";
+      }
+    }
+  }
+  {
+    let h = block.labelfontsize + labyspace2 + block.labelfontsize;
+    if (tk.label_stratify) {
+      h += tk.label_stratify.length * (labyspace2 + block.labelfontsize);
+    }
+    nm.toplabelheight = Math.max(nm.toplabelheight, h);
+  }
+  render_axis(tk, nm, block);
+  tk.skewer.g.append("line").attr("y1", nm.toplabelheight + nm.maxradius).attr("y2", nm.toplabelheight + nm.maxradius).attr("x2", block.width).attr("stroke", stemColor).attr("shape-rendering", "crispEdges");
+  tk.skewer.g.append("line").attr("y1", nm.toplabelheight + nm.maxradius + nm.axisheight).attr("y2", nm.toplabelheight + nm.maxradius + nm.axisheight).attr("x2", block.width).attr("stroke", stemColor).attr("shape-rendering", "crispEdges");
+  tk.skewer.nmg = tk.skewer.g.selectAll().data(data).enter().append("g").attr("class", "sja_skg2").each(function(d) {
+    d.g = this;
+  });
+  tk.skewer.nmg.attr(
+    "transform",
+    (d) => "translate(" + d.x + "," + (nm.toplabelheight + disclabelspacing2 + nm.maxradius + nm.axisheight + nm.maxradius) + ")"
+  );
+  if (showstem) {
+    tk.skewer.nmg.append("path").attr("class", "sja_aa_stem").attr("d", (d) => setStem(d, nm)).attr("stroke", (d) => tk.color4disc(d.mlst[0])).attr("fill", (d) => d.mlst.length == 1 ? "none" : stemColor);
+  }
+  const discg = tk.skewer.nmg.selectAll().data((d) => d.mlst).enter().append("g").attr("class", "sja_aa_discg").each(function(m) {
+    m.g = this;
+    if (!m.shape.includes("Circle")) {
+      renderSkewerShapes(tk, nm, select_default(this));
+    } else {
+      select_default(this).append("circle").attr("fill", (m2) => shapes[m2.shape].isFilled ? tk.color4disc(m2) : "none").attr("stroke", (m2) => shapes[m2.shape].isFilled ? "white" : tk.color4disc(m2)).attr("r", (m2) => m2.radius - 0.5).attr("class", "sja_aa_disk_fill");
+    }
+  });
+  discg.attr("transform", (m) => {
+    return "translate(" + m.xoff + "," + (m._y + nm.maxradius) * -1 + ")";
+  });
+  tk.skewer.hlBoxG = discg.append("g");
+  const kick = renderShapeKick(nm, discg);
+  kick.attr("stroke", (m) => tk.color4disc(m)).attr("fill", "white").attr("class", "sja_aa_disckick").attr("fill-opacity", 0).attr("stroke-opacity", 0).on("mousedown", (event2) => {
+    event2.preventDefault();
+  }).on("mouseover", (event2, m) => {
+    m_mouseover(m, nm, tk);
+  }).on("mouseout", (event2, m) => {
+    m_mouseout(m, tk);
+  }).on("click", (event2, m) => {
+    click_variant({ mlst: [m] }, tk, block, event2.target.getBoundingClientRect(), event2.target);
+  });
+  const textlabels = discg.filter((m) => m.labattop || m.labatbottom).append("text").each(function(m) {
+    m.__svg_textlabel = this;
+  }).text((m) => tk.mnamegetter(m)).attr("font-size", (m) => {
+    m._labfontsize = Math.max(12, m.radius * 1.2);
+    return m._labfontsize;
+  }).attr("fill", (m) => tk.color4disc(m)).attr(
+    "x",
+    (m) => nm.showsamplebar || nm.showgenotypebyvalue ? nm.axisheight + nm.maxradius + 4 : m.radius + m.rimwidth + disclabelspacing2
+  ).attr("y", (m) => m._labfontsize * middlealignshift2).attr("class", "sja_aa_disclabel").attr("transform", (m) => "rotate(" + (m.labattop ? "-" : "") + "90)").on("mousedown", (event2) => {
+    event2.preventDefault();
+  }).on("mouseover", (event2, m) => m_mouseover(m, nm, tk)).on("mouseout", (event2, m) => m_mouseout(m, tk)).on("click", (event2, m) => {
+    click_variant({ mlst: [m] }, tk, block, event2.target.getBoundingClientRect(), event2.target.previousSibling);
+  });
+}
+function adjustview(data, nm, tk, block) {
+  let sumwidth = 0;
+  for (const d of data) {
+    let w = 0;
+    for (const m of d.mlst) {
+      w += 2 * (m.radius + m.rimwidth);
+    }
+    if (d.mlst.length == 1) {
+      d.width = w;
+    } else {
+      d.width = Math.min(maxclusterwidth, w);
+      const m0 = d.mlst[0];
+      const m1 = d.mlst[d.mlst.length - 1];
+      d.fixedgew = m0.radius + m0.rimwidth + m1.radius + m1.rimwidth;
+    }
+    sumwidth += d.width;
+  }
+  if (sumwidth <= block.width) {
+    let cum = 0;
+    for (const d of data) {
+      d.x = cum + d.mlst[0].radius + d.mlst[0].rimwidth;
+      cum += d.width;
+      if (d.mlst.length == 1) {
+        d.stemw = 0;
+      } else {
+        d.stemw = d.width - d.fixedgew;
+      }
+    }
+    horiplace1(data, block.width);
+    for (const d of data) {
+      d.xoffset = d.x - d.x0;
+      if (d.mlst.length == 1) {
+        d.mlst[0].xoff = 0;
+        d.stemw = 0;
+      } else {
+        d.stemw = d.width - d.fixedgew;
+        const span = d.stemw / (d.mlst.length - 1);
+        for (let i = 0; i < d.mlst.length; i++) {
+          d.mlst[i].xoff = span * i;
+        }
+      }
+    }
+    return true;
+  }
+  for (const d of data) {
+    d.x = d.x0;
+    d.xoffset = 0;
+    for (const m of d.mlst) {
+      m.xoff = 0;
+    }
+  }
+  return false;
+}
+function horiplace1(items, allwidth) {
+  for (let i = 0; i < items.length; i++) {
+    if (items[i].x0 < 0) continue;
+    if (items[i].x0 > allwidth) break;
+    while (1) {
+      let currsum = 0, newsum = 0;
+      for (let j = i; j < items.length; j++) {
+        const t = items[j];
+        if (t.x0 > allwidth) {
+          return;
+        }
+        currsum += Math.abs(t.x - t.x0 - t.stemw / 2);
+        t.x++;
+        newsum += Math.abs(t.x - t.x0 - t.stemw / 2);
+      }
+      if (items[i].x > items[i].x0 - items[i].stemw / 2) {
+        for (let j = i; j < items.length; j++) {
+          items[j].x--;
+        }
+        break;
+      }
+      const z = items[items.length - 1];
+      if (z.x + z.width / 2 >= allwidth) {
+        return;
+      }
+      if (newsum <= currsum) {
+      } else {
+        for (let j = i; j < items.length; j++) {
+          if (items[j].x0 > allwidth) {
+            break;
+          }
+          items[j].x--;
+        }
+        break;
+      }
+    }
+  }
+}
+function verticallabplace(data) {
+  const mlst = [];
+  for (const d of data) {
+    for (const m of d.mlst) {
+      mlst.push({
+        m,
+        w: 2 * (m.radius + m.rimwidth),
+        x: d.x0,
+        y: m._y
+      });
+    }
+  }
+  mlst.sort((i, j) => j.y - i.y);
+  for (let i = 0; i < mlst.length; i++) {
+    const big = mlst[i];
+    let overlapwithdisc = false;
+    for (let j = 0; j < i; j++) {
+      const small = mlst[j];
+      if (Math.abs(big.x - small.x) < (big.w + small.w) / 2 - 2) {
+        overlapwithdisc = true;
+        break;
+      }
+    }
+    if (!overlapwithdisc) {
+      big.m.labattop = true;
+    }
+  }
+  for (let i = mlst.length - 1; i >= 0; i--) {
+    const big = mlst[i];
+    if (big.m.labattop) continue;
+    let overlapwithlabeleddisc = false;
+    for (let j = mlst.length - 1; j > i; j--) {
+      const small = mlst[j];
+      if (small.m.labatbottom && Math.abs(small.x - big.x) < (small.w + big.w) / 2 - 2) {
+        overlapwithlabeleddisc = true;
+        break;
+      }
+    }
+    if (!overlapwithlabeleddisc) {
+      big.m.labatbottom = true;
+    }
+  }
+}
+function setStem(d, nm) {
+  if (d.mlst.length == 1) {
+    return "M0,0v" + nm.stem1 + "l" + -d.xoffset + "," + nm.stem2 + "v" + nm.stem3;
+  }
+  return "M0,0v" + nm.stem1 + // vertical down
+  "l" + -d.xoffset + "," + nm.stem2 + // slope 1
+  "v" + nm.stem3 + // vertical down
+  //+'h1' // to right 1
+  "v-" + nm.stem3 + // veritical up
+  "l" + (d.stemw + d.xoffset - 1) + ",-" + nm.stem2 + // slope 2
+  "v-" + nm.stem1;
+}
+function m_mouseover(m, nm, tk) {
+  if (m.__svg_textlabel) {
+    select_default(m.__svg_textlabel).attr("font-size", m._labfontsize * 1.1);
+  }
+  tk.pica.g.attr(
+    "transform",
+    "translate(" + (m.aa.x + m.xoff) + "," + (nm.toplabelheight + nm.maxradius + nm.axisheight - m._y) + ")"
+  );
+  const linelen = 10;
+  const boxpad = 4;
+  const fontsize = m._labfontsize || 13;
+  const color = tk.color4disc(m);
+  const words = [];
+  if (nm.tooltipPrintValue) {
+    const out = nm.tooltipPrintValue(m);
+    if (Array.isArray(out)) {
+      words.push(...out.map((i) => `${i.k} = ${i.v}`));
+    }
+  } else {
+    words.push(nm.label + " = " + (m.__value_missing ? "NA" : m.__value_use));
+  }
+  if (tk.mds.queries?.ld?.mOverlay?.data) {
+    if (m.ssm_id == tk.mds.queries.ld.mOverlay.m.ssm_id) {
+    } else {
+      let r2 = "?";
+      for (const v of tk.mds.queries.ld.mOverlay.data) {
+        if (v.pos == m.pos && v.alleles == m.ref + "." + m.alt) {
+          r2 = v.r2;
+          break;
+        }
+      }
+      words.push("r2 = " + r2);
+    }
+  }
+  if (!m.labattop && !m.labatbottom) {
+    words.push(tk.mnamegetter(m));
+  }
+  let textw = 0;
+  for (const w of words) {
+    tk.pica.g.append("text").attr("font-size", fontsize).text(w).each(function() {
+      textw = Math.max(textw, this.getBBox().width);
+    }).remove();
+  }
+  const boxw = boxpad * 2 + textw;
+  let boxx, linex1, onleft = true;
+  if (boxw + linelen > m.aa.x + m.xoff) {
+    onleft = false;
+    linex1 = m.radius + m.rimwidth;
+    boxx = linex1 + linelen;
+  } else {
+    linex1 = -m.radius - m.rimwidth - linelen;
+    boxx = linex1 - boxw;
+  }
+  const boxh = fontsize * words.length;
+  tk.pica.g.append("rect").attr("x", boxx - 2).attr("y", -2 - boxpad - boxh / 2).attr("width", 4 + boxw).attr("height", 4 + boxpad * 2 + boxh).attr("fill", "white");
+  tk.pica.g.append("line").attr("x1", linex1).attr("x2", linex1 + linelen).attr("stroke", "white").attr("stroke-width", 3).attr("shape-rendering", "crispEdges");
+  tk.pica.g.append("line").attr("x1", linex1).attr("x2", linex1 + linelen).attr("stroke", color).attr("shape-rendering", "crispEdges");
+  tk.pica.g.append("rect").attr("x", boxx).attr("y", -boxpad - boxh / 2).attr("width", boxw).attr("height", boxpad * 2 + boxh).attr("fill", "none").attr("stroke", color).attr("shape-rendering", "crispEdges");
+  let y = (fontsize - boxh) / 2;
+  for (const w of words) {
+    tk.pica.g.append("text").text(w).attr("text-anchor", onleft ? "end" : "start").attr("font-size", fontsize).attr("x", onleft ? linex1 - boxpad : boxx + boxpad).attr("y", y).attr("fill", color).attr("dominant-baseline", "central");
+    y += fontsize;
+  }
+}
+function m_mouseout(m, tk) {
+  if (m.__svg_textlabel) {
+    select_default(m.__svg_textlabel).attr("font-size", m._labfontsize);
+  }
+  tk.pica.g.selectAll("*").remove();
+}
+function setup_axis_scale(data, nm, tk) {
+  for (const g of data) {
+    for (const m of g.mlst) {
+      delete m.__value_use;
+      delete m.__value_missing;
+    }
+  }
+  if (nm.byAttribute) {
+    for (const g of data) {
+      for (const m of g.mlst) {
+        const v = m[nm.byAttribute];
+        if (Number.isFinite(v)) {
+          m.__value_use = v;
+        } else {
+          m.__value_missing = true;
+        }
+      }
+    }
+  } else if (nm.byInfo) {
+    for (const g of data) {
+      for (const m of g.mlst) {
+        const v = m?.info?.[nm.byInfo];
+        if (Number.isFinite(v)) {
+          m.__value_use = v;
+        } else {
+          m.__value_missing = true;
+        }
+      }
+    }
+  } else {
+    throw "unknown method of getting value";
+  }
+  if (nm.axisSetting.auto) {
+    nm.minvalue = null;
+    nm.maxvalue = null;
+    for (const g of data) {
+      for (const m of g.mlst) {
+        if ("__value_use" in m) {
+          if (nm.minvalue == null) {
+            nm.minvalue = m.__value_use;
+            nm.maxvalue = m.__value_use;
+          } else {
+            nm.minvalue = Math.min(nm.minvalue, m.__value_use);
+            nm.maxvalue = Math.max(nm.maxvalue, m.__value_use);
+          }
+        }
+      }
+    }
+  } else if (nm.axisSetting.fixed) {
+    nm.minvalue = nm.axisSetting.fixed.min;
+    nm.maxvalue = nm.axisSetting.fixed.max;
+  } else {
+    throw "unknown axisSetting";
+  }
+}
+function render_axis(tk, nm, block) {
+  nm.axisg.attr("transform", "translate(0," + (nm.toplabelheight + nm.maxradius) + ")").selectAll("*").remove();
+  const thisscale = linear().domain([nm.minvalue, nm.maxvalue]).range([nm.axisheight, 0]);
+  const thisaxis = axisLeft().scale(thisscale).ticks(4);
+  if (nm.isinteger) {
+    thisaxis.tickFormat(format("d"));
+    if (nm.maxvalue - nm.minvalue < 3) {
+      thisaxis.ticks(nm.maxvalue - nm.minvalue);
+    }
+  }
+  axisstyle({
+    axis: nm.axisg.call(thisaxis),
+    showline: true,
+    fontsize: nm.dotwidth
+  });
+  nm.axisWidth = 0;
+  nm.axisg.selectAll("text").each(function() {
+    nm.axisWidth = Math.max(nm.axisWidth, this.getBBox().width);
+  });
+  nm.axisWidth += 15;
+  let w;
+  nm.axisg.append("text").attr("fill", "black").attr("font-size", nm.dotwidth).attr("dominant-baseline", "central").attr("text-anchor", "end").attr("class", "sjpp-mds3-nm-axislabel sja_clbtext2").attr("y", nm.axisheight / 2).attr("x", -nm.axisWidth).text(nm.label || defaultLabel).each(function() {
+    w = this.getBBox().width;
+  }).on("click", (event2) => {
+    tk.menutip.clear().showunder(event2.target).d.append("div").text("Cancel").attr("class", "sja_menuoption").style("border-radius", "0px").on("click", () => {
+      tk.menutip.hide();
+      nm.inuse = false;
+      tk.skewer.viewModes.find((i) => i.type == "skewer").inuse = true;
+      may_render_skewer({ skewer: tk.skewer.rawmlst }, tk, block);
+      positionLeftlabelg(tk, block);
+      tk._finish();
+    });
+    makeNumericAxisConfig({
+      holder: tk.menutip.d.append("div").style("margin", "10px"),
+      noPercentile: true,
+      callback: (s) => {
+        nm.axisSetting = s;
+        clearTk(tk);
+        numeric_make(nm, tk, block);
+      },
+      setting: nm.axisSetting
+    });
+  });
+  tk.skewer.maxwidth = nm.axisWidth + w;
+}
+function mayHighlightByLDoverlay(tk) {
+  const m = tk.mds.queries?.ld?.mOverlay?.m;
+  if (!m) return;
+  tk.skewer.hlssmid = /* @__PURE__ */ new Set([m.ssm_id]);
+  mayHighlightDiskBySsmid(tk);
+}
+
+// mds3/skewer.js
+var minMnameCount2compact = 10;
+function may_render_skewer(data, tk, block) {
+  if (!tk.skewer) {
+    return;
+  }
+  tk.skewer.maxwidth = 0;
+  updateViewModes(tk, data.skewer);
+  hlaachange2ssmid(tk, data.skewer);
+  const currentMode = tk.skewer.viewModes.find((n) => n.inuse);
+  if (!currentMode) throw "no mode!!";
+  if (data.skewer) {
+    tk.skewer.rawmlst = data.skewer;
+    data.skewer.forEach((d) => {
+      if (!d.id) d.id = Math.random().toString();
+    });
+  } else {
+    tk.skewer.rawmlst.forEach((d) => {
+      if (!d.id) d.id = Math.random().toString();
+    });
+  }
+  if (currentMode.type == "numeric") {
+    tk.subtk2height.skewer = renderNumericMode(currentMode, data, tk, block);
+    mayHighlightDiskBySsmid(tk);
+    return;
+  }
+  if (currentMode.type != "skewer") throw 'mode.type is not "skewer"';
+  if (data && !data.skewer && block.usegm && block.gmmode != "genomic" && block.pannedpx != void 0) {
+    tkdata_update_x(tk, block);
+    tk.skewer.selection.attr("transform", (d) => "translate(" + d.x + "," + d.y + ")");
+    settle_glyph(tk, block);
+  } else {
+    tk.skewer.g.selectAll("*").remove();
+    tk.skewer.data = make_skewer_data(tk, block);
+    skewer_make(tk, block);
+  }
+  if (!tk.skewer.data || tk.skewer.data.length == 0) {
+    tk.subtk2height.skewer = 0;
+    tk.skewer.g.selectAll("*").remove();
+    return;
+  }
+  if (tk.skewer.hlssmid) {
+    const fold = [];
+    const unfold = [];
+    for (const d of tk.skewer.data) {
+      let has = false;
+      for (const g of d.groups) {
+        for (const m of g.mlst) {
+          if (tk.skewer.hlssmid.has(m.ssm_id)) {
+            has = true;
+            break;
+          }
+        }
+      }
+      if (has) {
+        unfold.push(d);
+      } else {
+        fold.push(d);
+      }
+    }
+    fold_glyph(fold, tk);
+    unfold_glyph(unfold, tk, block);
+    mayHighlightDiskBySsmid(tk);
+  } else {
+    settle_glyph(tk, block);
+  }
+  tk.subtk2height.skewer = tk.skewer.maxheight + tk.skewer.stem1 + tk.skewer.stem2 + tk.skewer.stem3;
+}
+function hlaachange2ssmid(tk, mlst) {
+  if (!tk.hlaachange || !mlst) return;
+  const set = new Set(tk.hlaachange.split(","));
+  delete tk.hlaachange;
+  tk.skewer.hlssmid = /* @__PURE__ */ new Set();
+  for (const m of mlst) {
+    if (set.has(m.mname)) tk.skewer.hlssmid.add(m.ssm_id);
+  }
+}
+function tkdata_update_x(tk, block) {
+  for (const d of tk.skewer.data) {
+    if (d.isbin) {
+      let sumx = 0;
+      for (const m of d.mlst) {
+        const hits = block.seekcoord(m.chr, m.pos);
+        if (m.usehitidx != void 0 && hits[m.usehitidx]) {
+          sumx += hits[m.usehitidx].x;
+        } else if (hits.length == 1) {
+          sumx += hits[0].x;
+        } else {
+          console.log("cannot map item");
+          console.log(m);
+        }
+      }
+      d.x0 = sumx / d.mlst.length;
+      d.x = d.x0 + (d.xoffset != void 0 ? d.xoffset : 0);
+    } else {
+      const hits = block.seekcoord(d.chr, d.pos);
+      if (hits.length > 0) {
+        d.x0 = hits[0].x;
+        d.x = d.x0 + (d.xoffset != void 0 ? d.xoffset : 0);
+      } else {
+        console.log("cannot map group of item");
+        console.log(d);
+      }
+    }
+  }
+}
+function make_skewer_data(tk, block) {
+  const datagroup = make_datagroup(tk, tk.skewer.rawmlst, block);
+  for (const g of datagroup) {
+    g.groups = mlst2disc(g.mlst, tk);
+  }
+  if (tk.skewer.data && block.pannedpx != void 0) {
+    const pastmode = {};
+    for (const g of tk.skewer.data) {
+      pastmode[g.chr + "." + g.pos] = {
+        mode: g.showmode,
+        xoffset: g.xoffset,
+        slabelrotate: g.slabelrotate
+        // no effect
+      };
+    }
+    for (const g of datagroup) {
+      const k = g.chr + "." + g.pos;
+      if (pastmode[k]) {
+        g.showmode = pastmode[k].mode;
+        g.xoffset = pastmode[k].xoffset;
+        g.slabelrotate = pastmode[k].slabelrotate;
+      }
+    }
+  }
+  for (const d of datagroup) {
+    d.occurrence = d.groups.reduce((i, j) => i + j.occurrence, 0);
+  }
+  return datagroup;
+}
+function mlst2disc(mlst, tk) {
+  const k2g = /* @__PURE__ */ new Map();
+  for (const m of mlst) {
+    if (!Number.isInteger(m.dt)) continue;
+    if (!k2g.has(m.dt)) k2g.set(m.dt, /* @__PURE__ */ new Map());
+    switch (m.dt) {
+      case dtsnvindel:
+        if (!k2g.get(m.dt).has(m.class)) k2g.get(m.dt).set(m.class, /* @__PURE__ */ new Map());
+        const n = m.mname || "";
+        if (!k2g.get(m.dt).get(m.class).has(n)) {
+          k2g.get(m.dt).get(m.class).set(n, []);
+        }
+        k2g.get(m.dt).get(m.class).get(n).push(m);
+        break;
+      case dtsv:
+      case dtfusionrna:
+        if (!k2g.get(m.dt).has(m.class)) {
+          k2g.get(m.dt).set(m.class, {
+            use5: /* @__PURE__ */ new Map(),
+            use3: /* @__PURE__ */ new Map()
+          });
+        }
+        if (m.useNterm) {
+          if (!k2g.get(m.dt).get(m.class).use5.has(m.mname)) {
+            k2g.get(m.dt).get(m.class).use5.set(m.mname, []);
+          }
+          k2g.get(m.dt).get(m.class).use5.get(m.mname).push(m);
+        } else {
+          if (!k2g.get(m.dt).get(m.class).use3.has(m.mname)) {
+            k2g.get(m.dt).get(m.class).use3.set(m.mname, []);
+          }
+          k2g.get(m.dt).get(m.class).use3.get(m.mname).push(m);
+        }
+        break;
+      case dtitd:
+      case dtdel:
+      case dtnloss:
+      case dtcloss:
+        if (!k2g.has(m.dt)) {
+          k2g.set(m.dt, []);
+        }
+        k2g.get(m.dt).push(m);
+        break;
+      default:
+        console.log("unknown datatype: " + m.dt);
+        console.log(m);
+        return;
+    }
+  }
+  const groups = [];
+  for (const [dt, tmp] of k2g) {
+    switch (dt) {
+      case dtsnvindel:
+        for (const [thisClass, mname2lst] of tmp) {
+          if (mname2lst.size > minMnameCount2compact) {
+            const mlst2 = [];
+            for (const l2 of mname2lst.values()) mlst2.push(...l2);
+            groups.push({
+              dt,
+              mlst: mlst2,
+              mnameCompact: mclass[thisClass].label
+            });
+          } else {
+            for (const mlst2 of mname2lst.values()) {
+              groups.push({ dt, mlst: mlst2 });
+            }
+          }
+        }
+        break;
+      case dtsv:
+      case dtfusionrna:
+        for (const classset of tmp.values()) {
+          if (classset.use5.size > minMnameCount2compact) {
+            const mlst2 = [];
+            for (const l2 of classset.use5.values()) mlst2.push(...l2);
+            groups.push({ dt, mlst: mlst2, useNterm: true, mnameCompact: dt == dtsv ? "SV" : "fusion" });
+          } else {
+            for (const mlst2 of classset.use5.values()) {
+              groups.push({ dt, mlst: mlst2, useNterm: true });
+            }
+          }
+          if (classset.use3.size > minMnameCount2compact) {
+            const mlst2 = [];
+            for (const l2 of classset.use3.values()) mlst2.push(...l2);
+            groups.push({ dt, mlst: mlst2, useNterm: false, mnameCompact: dt == dtsv ? "SV" : "fusion" });
+          } else {
+            for (const mlst2 of classset.use3.values()) {
+              groups.push({ dt, mlst: mlst2, useNterm: false });
+            }
+          }
+        }
+        break;
+      case dtitd:
+      case dtdel:
+      case dtnloss:
+      case dtcloss:
+        groups.push({
+          dt,
+          mlst: tmp
+        });
+    }
+  }
+  for (const g of groups) {
+    let rim1count = 0, rim2count = 0;
+    for (const m of g.mlst) {
+      rim1count += m.rim1count || 0;
+      rim2count += m.rim2count || 0;
+    }
+    g.rim1count = rim1count;
+    g.rim2count = rim2count;
+  }
+  if (mlst.some((m) => Number.isFinite(m.occurrence))) {
+    for (const g of groups) g.occurrence = g.mlst.reduce((i, j) => i + j.occurrence, 0);
+  } else {
+    for (const g of groups) g.occurrence = g.mlst.length;
+  }
+  groups.sort((a, b) => {
+    return b.occurrence - a.occurrence;
+  });
+  return groups;
+}
+function updateViewModes(tk, mlst) {
+  detectNumericMode(tk, mlst);
+  detectAlternativeSkewerModes(tk, mlst);
+  for (const n of tk.skewer.viewModes) {
+    if (n.type == "numeric" && !n.inuse && n.axisg) {
+      n.axisg.remove();
+      delete n.axisg;
+    }
+  }
+}
+function detectAlternativeSkewerModes(tk) {
+}
+function detectNumericMode(tk, mlst) {
+  if (mlst && mlst.find((i) => Number.isFinite(i.occurrence))) {
+    if (!tk.skewer.viewModes.find((n) => n.type == "numeric" && n.byAttribute == "occurrence")) {
+      tk.skewer.viewModes.push({
+        type: "numeric",
+        byAttribute: "occurrence",
+        label: "Occurrence",
+        isinteger: true
+      });
+    }
+  }
+}
+
+// mds3/leftlabel.variant.js
+function makeVariantLabel(data, tk, block, laby) {
+  if (!tk.skewer && !tk.cnv) return;
+  if (!tk.leftlabels.doms.variants) {
+    tk.leftlabels.doms.variants = makelabel(tk, block, laby);
+    tk.leftlabels.doms.variants.attr("data-testid", "sja_variants_label");
+    if (data.variantAlerts?.length) tk.leftlabels.doms.variants.attr("fill", "red");
+  }
+  const [labeltext, totalcount, showcount] = getVariantLabelText(data, tk, block);
+  if (totalcount == 0) {
+    tk.leftlabels.doms.variants.text(labeltext).attr("class", "").style("opacity", 0.7).on("click", null);
+    return;
+  }
+  if (showcount == 0) {
+    tk.leftlabels.doms.variants.text(labeltext).attr("class", "").style("opacity", 0.5).on("click", null);
+    return;
+  }
+  tk.leftlabels.doms.variants.style("opacity", 1).attr("class", "sja_clbtext2").text(labeltext).on("click", (event2) => {
+    tk.menutip.clear().showunder(event2.target);
+    menu_variants(data, tk, block);
+  });
+}
+function getVariantLabelText(data, tk, block) {
+  let totalcount = 0, showcount = 0;
+  const dtset = /* @__PURE__ */ new Set();
+  if (tk.custom_variants) {
+    totalcount = tk.custom_variants.length;
+    for (const m of tk.custom_variants) dtset.add(m.dt);
+  } else {
+    if (tk.skewer?.rawmlst) {
+      totalcount += tk.skewer.rawmlst.length;
+      for (const m of tk.skewer.rawmlst) dtset.add(m.dt);
+    }
+    if (data.cnv) {
+      totalcount += data.cnv.cnvs.length;
+      for (const m of data.cnv.cnvs) dtset.add(m.dt);
+    } else if (data.cnvDensity) {
+      totalcount += data.cnvDensity.segmentCount;
+      dtset.add(dtcnv);
+    }
+  }
+  if (totalcount == 0) return ["No data", 0, 0];
+  if (tk.skewer) {
+    const currentMode = tk.skewer.viewModes.find((i) => i.inuse);
+    if (currentMode.type == "skewer") {
+      showcount = tk.skewer.data.filter((i) => i.x >= 0 && i.x <= block.width).reduce((i, j) => i + j.mlst.length, 0);
+    } else if (currentMode.type == "numeric") {
+      showcount = currentMode.data.filter((i) => i.x >= 0 && i.x <= block.width).reduce((i, j) => i + j.mlst.length, 0);
+    } else {
+      throw "unknown mode type";
+    }
+  }
+  if (data.cnv) {
+    showcount += data.cnv.cnvs.length;
+  } else if (data.cnvDensity) {
+    showcount += data.cnvDensity.segmentCount;
+  }
+  let vn = "variant";
+  if (dtset.size == 1) {
+    const dt = [...dtset][0];
+    if (dt == dtsnvindel) {
+    } else {
+      vn = dt2label[dt];
+    }
+  }
+  if (showcount == 0) {
+    return [`0 out of ${totalcount} ${vn}${totalcount > 1 ? "s" : ""}`, totalcount, showcount];
+  }
+  return [
+    showcount < totalcount ? showcount + " of " + totalcount + " " + vn + "s" : showcount + " " + vn + (showcount > 1 ? "s" : ""),
+    totalcount,
+    showcount
+  ];
+}
+function menu_variants(data, tk, block) {
+  if (data.variantAlerts?.length) {
+    for (const m of data.variantAlerts) {
+      tk.menutip.d.append("div").style("margin", "10px").style("font-size", ".8em").style("color", "red").text(m);
+    }
+  }
+  if ((!tk.skewer?.rawmlst || tk.skewer.rawmlst?.length == 0) && tk.cnv?.cnvInDensity) {
+    tk.menutip.d.append("div").style("margin", "10px").text("Viewing CNV segment density, no information on individual segments.");
+    if (tk.cnv.cnvMsg) {
+      tk.menutip.d.append("div").style("margin", "10px").text(tk.cnv.cnvMsg);
+    }
+    return;
+  }
+  const listDiv = tk.menutip.d.append("div").text("List").attr("class", "sja_menuoption sja_sharp_border").attr("data-testid", "sjpp_mds3tk_variantleftlabel_list").attr("tabindex", 0).on("click", () => {
+    listVariantData(tk, block);
+  });
+  listDiv.node().focus();
+  setTimeout(() => listDiv.node().blur(), 2e3);
+  if (tk.skewer && !tk.hardcodeCnvOnly) {
+    if (tk.skewer.hlssmid) {
+      tk.menutip.d.append("div").text("Cancel highlight").attr("class", "sja_menuoption sja_sharp_border").attr("tabindex", 0).on("click", () => {
+        delete tk.skewer.hlssmid;
+        tk.skewer.hlBoxG.selectAll("*").remove();
+        const currentMode = tk.skewer.viewModes.find((i) => i.inuse);
+        if (currentMode.type == "skewer") {
+          settle_glyph(tk, block);
+        } else if (currentMode.type == "numeric") {
+        } else {
+          throw "unknown mode type";
+        }
+        tk.menutip.hide();
+      });
+    }
+    const vm = tk.skewer.viewModes.find((n) => n.inuse);
+    if (vm.type == "skewer") {
+      const expandCount = tk.skewer.data.reduce((i, j) => i + j.showmode, 0);
+      if (expandCount > 0) {
+        tk.menutip.d.append("div").text("Collapse").attr("class", "sja_menuoption sja_sharp_border").attr("data-testid", "sja_collapse_menuoption").attr("tabindex", 0).on("click", () => {
+          fold_glyph(tk.skewer.data, tk);
+          tk.menutip.hide();
+        });
+      } else if (expandCount == 0) {
+        tk.menutip.d.append("div").text("Expand").attr("class", "sja_menuoption sja_sharp_border").attr("data-testid", "sja_expand_menuoption").attr("tabindex", 0).on("click", () => {
+          settle_glyph(tk, block);
+          tk.menutip.hide();
+        });
+      }
+      tk.menutip.d.append("div").text(tk.skewer.pointup ? "Point down" : "Point up").attr("class", "sja_menuoption sja_sharp_border").attr("tabindex", 0).on("click", () => {
+        tk.skewer.pointup = !tk.skewer.pointup;
+        tk.load();
+        tk.menutip.hide();
+      });
+      if (tk.filterObj) {
+        let called = false;
+        const div = tk.menutip.d.append("div").text("Change variant shape").style("vertical-align", "middle").attr("class", "sja_menuoption sja_sharp_border").attr("tabindex", 0).on("click", () => {
+          if (called == false) {
+            called = true;
+            renderShapePicker({
+              holder: div.append("div").style("margin-top", "10px"),
+              callback: (shape) => {
+                Object.keys(tk.shapes).forEach((key) => {
+                  tk.shapes[key] = shape;
+                });
+                tk.load();
+                tk.menutip.hide();
+              },
+              tk
+            });
+          }
+        });
+      }
+    } else if (vm.type == "numeric") {
+      tk.menutip.d.append("div").text(tk.skewer.hideDotLabels ? "Show all variant labels" : "Hide all variant labels").attr("class", "sja_menuoption sja_sharp_border").attr("tabindex", 0).on("click", () => {
+        tk.skewer.hideDotLabels = !tk.skewer.hideDotLabels;
+        tk.load();
+        tk.menutip.hide();
+      });
+    }
+  }
+  if (!tk.custom_variants) {
+    tk.menutip.d.append("div").text("Download").attr("class", "sja_menuoption sja_sharp_border").attr("tabindex", 0).attr("data-testid", "sjpp_mds3tk_variantdownload_menuoption").on("click", () => {
+      downloadVariants(tk, block);
+      tk.menutip.hide();
+    });
+  }
+  tk.menutip.d.on("keydown", function(event2) {
+    if (event2.key != "Enter" || !event2.target.className.includes("sja_menuoption")) return;
+    event2.target.dispatchEvent(new KeyboardEvent("click"));
+  });
+  mayAddSkewerModeOption(tk, block);
+}
+async function listVariantData(tk, block) {
+  tk.menutip.clear();
+  const dt2mlst = /* @__PURE__ */ new Map();
+  if (tk.skewer) {
+    const currentMode = tk.skewer.viewModes.find((i2) => i2.inuse);
+    let data;
+    if (currentMode.type == "skewer") {
+      data = tk.skewer.data.filter((i2) => i2.x >= 0 && i2.x <= block.width);
+    } else if (currentMode.type == "numeric") {
+      data = currentMode.data;
+    } else {
+      throw "unknown mode type";
+    }
+    for (const g of data) {
+      for (const m of g.mlst) {
+        if (!dt2mlst.has(m.dt)) dt2mlst.set(m.dt, []);
+        dt2mlst.get(m.dt).push(m);
+      }
+    }
+  }
+  if (tk.cnv?.cnvLst?.length) {
+    dt2mlst.set(dtcnv, tk.cnv.cnvLst);
+  }
+  if (dt2mlst.size == 1) {
+    const div = tk.menutip.d.append("div").style("margin", "10px");
+    await itemtable({
+      div,
+      mlst: dt2mlst.get([...dt2mlst.keys()][0]),
+      tk,
+      block,
+      doNotListSample4multim: true
+    });
+    return;
+  }
+  const tabs = [];
+  for (const [dt, mlst] of dt2mlst) {
+    tabs.push({ label: mlst.length + " " + dt2label[dt] });
+  }
+  new Tabs({
+    holder: tk.menutip.d.append("div").attr("class", "sja_pp_vlb_dttabdiv").style("margin", "10px"),
+    tabs
+  }).main();
+  let i = 0;
+  for (const [dt, mlst] of dt2mlst) {
+    itemtable({
+      div: tabs[i++].contentHolder.append("div").style("margin-left", "10px"),
+      mlst,
+      tk,
+      block,
+      doNotListSample4multim: true
+    });
+  }
+}
+function renderShapePicker(arg) {
+  const lollipopShapes = {
+    filledCircle: shapes.filledCircle,
+    emptyCircle: shapes.emptyCircle,
+    filledVerticalRectangle: shapes.filledVerticalRectangle,
+    emptyVerticalRectangle: shapes.emptyVerticalRectangle,
+    filledTriangle: shapes.filledTriangle,
+    emptyTriangle: shapes.emptyTriangle,
+    filledSquare: shapes.filledSquare,
+    emptySquare: shapes.emptySquare
+  };
+  const { holder, callback, tk } = arg;
+  const shapePaths = Object.values(lollipopShapes).map((shape) => shape.path);
+  const selectorCallback = (val) => {
+    const shape = Object.keys(lollipopShapes)[val];
+    callback(shape, tk);
+  };
+  const opts = { backgroundColor: "" };
+  shapeSelector(holder, selectorCallback, shapePaths, opts);
+}
+function mayAddSkewerModeOption(tk, block) {
+  if (!tk.skewer) return;
+  if (tk.skewer.viewModes.length <= 1) {
+    return;
+  }
+  const options = [];
+  for (const [idx, v] of tk.skewer.viewModes.entries()) {
+    const o = {
+      label: getViewmodeName(v),
+      value: idx
+    };
+    if (v.inuse) o.checked = true;
+    options.push(o);
+  }
+  make_radios({
+    holder: tk.menutip.d.append("div").attr("class", "sja_pp_vlb_viewmoderadiodiv").style("margin", "10px"),
+    styles: {
+      display: "block"
+    },
+    options,
+    callback: async (idx) => {
+      for (const i of tk.skewer.viewModes) i.inuse = false;
+      tk.skewer.viewModes[idx].inuse = true;
+      may_render_skewer({ skewer: tk.skewer.rawmlst }, tk, block);
+      positionLeftlabelg(tk, block);
+      tk._finish();
+    }
+  });
+}
+function getViewmodeName(n) {
+  if (!n) return "MISSING!!";
+  if (n.type == "skewer") return "As lollipops";
+  if (n.type == "numeric") return n.label + " as Y axis";
+  return "unknown mode";
+}
+async function downloadVariants(tk, block) {
+  if (!tk.mds.variant2samples) {
+    console.log("TODO: variant-only");
+    return;
+  }
+  const arg = {
+    querytype: "samples"
+  };
+  rangequery_rglst(tk, block, arg);
+  const samples = (await tk.mds.variant2samples.get(arg)).samples;
+  const [columns, rows] = await samples2columnsRows(samples, tk);
+  const headerline = [];
+  for (const c of columns) {
+    if (c.isSsm) {
+      headerline.push("AAchange");
+      headerline.push("Consequence");
+      headerline.push("Mutation");
+      continue;
+    }
+    if (c.isMaf) {
+      headerline.push("Alternative allele depth in tumor");
+      headerline.push("Total depth in tumor");
+      continue;
+    }
+    headerline.push(c.label);
+  }
+  const lines = [];
+  for (const [sidx, sample] of samples.entries()) {
+    let ssm_id_lst;
+    if (Array.isArray(sample.ssm_id_lst)) {
+      ssm_id_lst = sample.ssm_id_lst;
+    } else if (sample.ssm_id) {
+      ssm_id_lst = [sample.ssm_id];
+    } else {
+      console.log("sample obj lacks ssm_id and ssm_id_lst");
+      continue;
+    }
+    for (const ssmid of ssm_id_lst) {
+      const m = findMbyId(ssmid, tk);
+      if (!m) {
+        console.log("ssm not found by id: " + ssmid);
+        continue;
+      }
+      const line = [];
+      for (const [cidx, c] of columns.entries()) {
+        if (c.isSsm) {
+          if (m.dt == dtsnvindel) {
+            line.push(m.mname);
+            line.push(mclass[m.class].label);
+            line.push(m.chr + ":" + (m.pos + 1) + " " + m.ref + ">" + m.alt);
+          } else if (m.dt == dtsv || m.dt == dtfusionrna) {
+            line.push("");
+            line.push(mclass[m.class].label);
+            line.push(
+              m.pairlst[0].a.chr + ":" + m.pairlst[0].a.pos + ">" + m.pairlst[0].b.chr + ":" + m.pairlst[0].b.pos
+            );
+          } else if (m.dt == dtcnv) {
+            line.push(Number.isFinite(m.value) ? m.value : "");
+            line.push(mclass[m.class].label);
+            line.push(m.chr + ":" + (m.start + 1) + "-" + (m.stop + 1));
+          } else {
+            throw "unknown m.dt";
+          }
+          continue;
+        }
+        const cell = rows[sidx][cidx];
+        if (cell.bySsmid) {
+          if (ssmid in cell.bySsmid) {
+            const v = cell.bySsmid[ssmid];
+            if (c.isMaf) {
+              line.push(v.altTumor);
+              line.push(v.totalTumor);
+            } else {
+              line.push(v);
+            }
+          } else {
+            line.push("");
+          }
+          continue;
+        }
+        if (c.isMaf) {
+          line.push(cell.altTumor);
+          line.push(cell.totalTumor);
+          continue;
+        }
+        line.push(cell.value);
+      }
+      lines.push(line.join("	"));
+    }
+  }
+  to_textfile(
+    block2source(block) + " " + (/* @__PURE__ */ new Date()).toLocaleDateString() + ".txt",
+    headerline.join("	") + "\n" + lines.join("\n")
+  );
+}
+
+// mds3/legend.js
+var unknown_infoCategory_color = "black";
+var unannotatedKey = "Unannotated";
+function initLegend(tk, block) {
+  if (!block.legend) return;
+  if (!tk.legend) tk.legend = {};
+  tk.legend.tip = new Menu({ padding: "0px" });
+  const [tr, td, td0] = legend_newrow(block, tk.name);
+  tk.legend.headTd = td0;
+  tk.tr_legend = tr;
+  const table = td.append("table").style("border-spacing", "5px").style("border-collapse", "separate");
+  tk.legend.table = table;
+  create_mclass(tk, block);
+  may_create_variantShapeName(tk);
+  may_create_infoFields(tk);
+  may_create_formatFilter(tk);
+  may_create_skewerRim(tk);
+  may_create_ld(tk);
+  may_create_cnv(tk);
+}
+function create_mclass(tk, block) {
+  if (!tk.legend.mclass) tk.legend.mclass = {};
+  if (!tk.legend.mclass.hiddenvalues) tk.legend.mclass.hiddenvalues = /* @__PURE__ */ new Set();
+  tk.legend.mclass.row = tk.legend.table.append("tr");
+  if (tk.hardcodeCnvOnly) {
+    tk.legend.mclass.row.style("display", "none");
+  }
+  tk.legend.mclass.row.append("td").style("text-align", "right").style("opacity", 0.7).text(block.mclassOverride ? block.mclassOverride.className || "Mutation" : "Mutation");
+  tk.legend.mclass.holder = tk.legend.mclass.row.append("td");
+}
+function may_create_variantShapeName(tk) {
+  if (!tk.legend.customShapeLabels || !tk.custom_variants) return;
+  if (!tk.legend.variantShapeName) tk.legend.variantShapeName = [];
+  for (const data of tk.custom_variants) {
+    if (!data.shape) data.shape = "filledCircle";
+    const shapeObj = tk.legend.variantShapeName.find((v) => v.key == data.shape);
+    if (!shapeObj) {
+      tk.legend.variantShapeName.push({
+        key: data.shape,
+        origShape: data.shape,
+        num: 1
+      });
+    } else {
+      shapeObj.num = ++shapeObj.num;
+    }
+  }
+  if (tk.legend.customShapeLabels) {
+    for (const shape in tk.legend.customShapeLabels) {
+      if (!tk.legend.variantShapeName.find((i) => i.key == shape)) {
+        tk.legend.variantShapeName.push({
+          key: shape,
+          origShape: shape,
+          num: 0
+        });
+      }
+    }
+  }
+  tk.legend.variantShapeName.sort((a, b) => b.num - a.num);
+  const width = 12;
+  const height = 12;
+  const shapesWrapper = tk.legend.table.append("tr").append("td").attr("colspan", 2);
+  for (const shapeObj of Object.values(tk.legend.variantShapeName)) {
+    const getArgs = () => {
+      return shapeObj.key.includes("Circle") ? { radius: width / 2 - 0.5 } : shapeObj.key.includes("Rectangle") ? { width: width / 2 + 2.5, height: height - 0.5 } : { width: width - 0.5, height: height - 0.5 };
+    };
+    shapeObj.wrapper = shapesWrapper.append("div");
+    const svg = shapeObj.wrapper.append("span").append("svg").attr("width", width).attr("height", height);
+    shapeObj.shapeG = svg.append("g").attr("transform", `translate(${width / 2}, ${height / 2})`).append("path").attr("d", shapes[shapeObj.key].calculatePath(getArgs(shapeObj))).attr("fill", shapes[shapeObj.key].isFilled ? "grey" : "white").attr("stroke", shapes[shapeObj.key].isFilled ? "none" : "grey");
+    shapeObj.wrapper.append("span").html(`&nbsp;n=`);
+    shapeObj.numDiv = shapeObj.wrapper.append("span").text(shapeObj.num);
+    shapeObj.wrapper.append("span").text(`, ${tk.legend.customShapeLabels[shapeObj.key]}`);
+  }
+}
+function may_create_infoFields(tk) {
+  if (!tk.mds.bcf?.info) return;
+  const infoFields4legend = [];
+  for (const key in tk.mds.bcf.info) {
+    const field = tk.mds.bcf.info[key];
+    if (field.categories) {
+      infoFields4legend.push(key);
+    }
+  }
+  if (!infoFields4legend.length) return;
+  if (!tk.legend.bcfInfo) tk.legend.bcfInfo = {};
+  for (const key of infoFields4legend) {
+    const row = tk.legend.table.append("tr");
+    row.append("td").style("text-align", "right").style("opacity", 0.7).text(tk.mds.bcf.info[key].name || key);
+    tk.legend.bcfInfo[key] = {
+      hiddenvalues: /* @__PURE__ */ new Set(),
+      row,
+      // column 2 <td>: content holder
+      holder: row.append("td")
+    };
+  }
+}
+function may_create_formatFilter(tk) {
+  if (!tk.mds.bcf?.format) return;
+  const formatFields4legend = [];
+  for (const k in tk.mds.bcf.format) {
+    if (tk.mds.bcf.format[k].isFilter) formatFields4legend.push(k);
+  }
+  if (!formatFields4legend.length) return;
+  if (!tk.legend.formatFilter) tk.legend.formatFilter = {};
+  for (const key of formatFields4legend) {
+    const row = tk.legend.table.append("tr");
+    row.append("td").style("text-align", "right").style("opacity", 0.7).text(tk.mds.bcf.format[key].Description);
+    tk.legend.formatFilter[key] = {
+      hiddenvalues: /* @__PURE__ */ new Set(),
+      row,
+      // column 2 <td>: content holder
+      holder: row.append("td")
+    };
+  }
+}
+function may_update_formatFilter(data, tk) {
+  if (!tk.legend.formatFilter) return;
+  if (!data.skewer) {
+    console.log("data.skewer[] is not present and cannot show INFO legend");
+    return;
+  }
+  for (const formatKey in tk.legend.formatFilter) {
+    tk.legend.formatFilter[formatKey].holder.selectAll("*").remove();
+    const category2variantCount = /* @__PURE__ */ new Map();
+    let unannotatedCount = 0;
+    for (const m of data.skewer) {
+      if (!m.formatK2count?.[formatKey]) continue;
+      for (const category in m.formatK2count[formatKey].v2c) {
+        category2variantCount.set(
+          category,
+          m.formatK2count[formatKey].v2c[category] + (category2variantCount.get(category) || 0)
+        );
+      }
+      unannotatedCount += m.formatK2count[formatKey].unannotatedCount || 0;
+    }
+    const show_lst = [...category2variantCount];
+    show_lst.sort((i, j) => j[1] - i[1]);
+    if (unannotatedCount) {
+      show_lst.push([unannotatedKey, unannotatedCount]);
+    }
+    for (const [category, count] of show_lst) {
+      const cell = tk.legend.formatFilter[formatKey].holder.append("div").attr("class", "sja_clb").style("display", "inline-block").on("click", () => {
+        const opts = [
+          {
+            label: "Hide",
+            isVisible: () => true,
+            callback: () => {
+              tk.legend.formatFilter[formatKey].hiddenvalues.add(category);
+            }
+          },
+          {
+            label: "Show only",
+            isVisible: () => true,
+            callback: () => {
+              for (const c2 of show_lst) {
+                tk.legend.formatFilter[formatKey].hiddenvalues.add(c2[0]);
+              }
+              tk.legend.formatFilter[formatKey].hiddenvalues.delete(category);
+            }
+          },
+          {
+            label: "Show all",
+            isVisible: () => tk.legend.formatFilter[formatKey].hiddenvalues.size,
+            callback: () => {
+              tk.legend.formatFilter[formatKey].hiddenvalues.clear();
+            }
+          }
+        ];
+        createLegendTipMenu(opts, tk, cell.node());
+      });
+      cell.append("div").style("display", "inline-block").attr("class", "sja_mcdot").style("background", "#aaa").style("margin-right", "5px").html(count > 1 ? count : "&nbsp;");
+      cell.append("div").style("display", "inline-block").text(category);
+    }
+    for (const c of tk.legend.formatFilter[formatKey].hiddenvalues) {
+      let loading = false;
+      tk.legend.formatFilter[formatKey].holder.append("div").style("display", "inline-block").attr("class", "sja_clb").style("text-decoration", "line-through").style("opacity", 0.7).text(c).on("click", async () => {
+        if (loading) return;
+        loading = true;
+        tk.legend.formatFilter[formatKey].hiddenvalues.delete(c);
+        reload(tk);
+      });
+    }
+  }
+}
+function reload(tk) {
+  tk.legend.tip.hide();
+  tk.load();
+}
+function updateLegend(data, tk, block) {
+  if (!tk.legend) {
+    return;
+  }
+  tk.legend.mclass.currentData = data.mclass2variantcount;
+  update_mclass(tk);
+  may_update_variantShapeName(data, tk);
+  may_update_infoFields(data, tk);
+  may_update_formatFilter(data, tk);
+  may_update_skewerRim(data, tk);
+  may_update_ld(tk);
+  may_update_cnv(tk);
+}
+function may_update_variantShapeName(data, tk) {
+  if (!tk.legend.customShapeLabels) return;
+  Object.values(tk.legend.variantShapeName).forEach((s) => {
+    if (!s.ids) {
+      s.ids = data.skewer.filter((d) => d.shape == s.key).map((i) => i.id);
+    }
+    s.num = 0;
+  });
+  for (const d of data.skewer) {
+    let shapeObj = tk.legend.variantShapeName.find((s) => s.ids.some((i) => i == d.id));
+    if (!shapeObj) {
+      shapeObj = tk.legend.variantShapeName.find((s) => s.key == d.shape || s.origShape == d.shape);
+      shapeObj.ids.push(d.id);
+    }
+    shapeObj.num = ++shapeObj.num;
+  }
+  Object.values(tk.legend.variantShapeName).forEach((s) => {
+    s.wrapper.style("display", s.num ? "block" : "none");
+    s.numDiv.text(s.num);
+  });
+}
+function may_update_infoFields(data, tk) {
+  if (!tk.legend.bcfInfo) return;
+  if (!data.skewer) {
+    console.log("data.skewer[] is not present and cannot show INFO legend");
+    return;
+  }
+  for (const infoKey in tk.legend.bcfInfo) {
+    tk.legend.bcfInfo[infoKey].holder.selectAll("*").remove();
+    if (tk.mds.bcf.info[infoKey].Type == "String") {
+      const category2variantCount = /* @__PURE__ */ new Map();
+      for (const m of data.skewer) {
+        const category = m.info?.[infoKey] || unannotatedKey;
+        if (Array.isArray(category)) {
+          for (const c of category) {
+            category2variantCount.set(c, 1 + (category2variantCount.get(c) || 0));
+          }
+        } else {
+          category2variantCount.set(category, 1 + (category2variantCount.get(category) || 0));
+        }
+      }
+      const show_lst = [...category2variantCount].sort((i, j) => j[1] - i[1]);
+      for (const [category, count] of show_lst) {
+        printCategory({
+          holder: tk.legend.bcfInfo[infoKey].holder,
+          key: category,
+          color: tk.mds.bcf.info[infoKey].categories?.[category]?.color || unknown_infoCategory_color,
+          label: tk.mds.bcf.info[infoKey].categories?.[category]?.label || category,
+          count,
+          click: (event2) => {
+            const opts = [
+              {
+                label: "Hide",
+                isVisible: () => true,
+                callback: () => {
+                  tk.legend.bcfInfo[infoKey].hiddenvalues.add(category);
+                }
+              },
+              {
+                label: "Show only",
+                isVisible: () => true,
+                callback: () => {
+                  for (const c2 of show_lst) {
+                    tk.legend.bcfInfo[infoKey].hiddenvalues.add(c2[0]);
+                  }
+                  tk.legend.bcfInfo[infoKey].hiddenvalues.delete(category);
+                }
+              },
+              {
+                label: "Show all",
+                isVisible: () => tk.legend.bcfInfo[infoKey].hiddenvalues.size,
+                callback: () => {
+                  tk.legend.bcfInfo[infoKey].hiddenvalues.clear();
+                }
+              }
+            ];
+            createLegendTipMenu(opts, tk, event2.target);
+            const desc = tk.mds.bcf.info[infoKey].categories?.[category]?.desc;
+            if (desc) {
+              tk.legend.tip.d.append("div").style("padding", "10px").style("font-size", ".8em").style("width", "150px").html(desc);
+            }
+          }
+        });
+      }
+      for (const c of tk.legend.bcfInfo[infoKey].hiddenvalues) {
+        let loading = false;
+        tk.legend.bcfInfo[infoKey].holder.append("div").style("display", "inline-block").attr("class", "sja_clb").style("text-decoration", "line-through").text(c).on("click", async () => {
+          if (loading) return;
+          loading = true;
+          tk.legend.bcfInfo[infoKey].hiddenvalues.delete(c);
+          reload(tk);
+        });
+      }
+    }
+  }
+}
+function update_mclass(tk) {
+  if (tk.hardcodeCnvOnly) return;
+  if (!tk.legend.mclass.currentData || tk.legend.mclass.currentData.length == 0) return;
+  tk.legend.mclass.holder.selectAll("*").remove();
+  const showlst = [], hiddenlst = [];
+  for (const [k, count] of tk.legend.mclass.currentData) {
+    const v = { k, count };
+    if (tk.legend.mclass.hiddenvalues.has(k)) {
+      hiddenlst.push(v);
+    } else {
+      showlst.push(v);
+    }
+  }
+  showlst.sort((i, j) => j.count - i.count);
+  hiddenlst.sort((i, j) => j.count - i.count);
+  for (const k of tk.legend.mclass.hiddenvalues) {
+    if (!hiddenlst.find((i) => i.k == k)) {
+      hiddenlst.push({ k });
+    }
+  }
+  for (const c of showlst) {
+    const { label, desc, color } = mds3tkMclass(c.k);
+    printCategory({
+      holder: tk.legend.mclass.holder,
+      key: c.k,
+      label: tk.mds.termdbConfig?.mclass?.[c.k]?.label || label,
+      color,
+      count: c.count,
+      click: () => {
+        const opts = [
+          {
+            label: "Hide",
+            isVisible: () => true,
+            callback: () => {
+              tk.legend.mclass.hiddenvalues.add(c.k);
+            }
+          },
+          {
+            label: "Show only",
+            isVisible: () => true,
+            callback: () => {
+              for (const c2 of showlst) {
+                tk.legend.mclass.hiddenvalues.add(c2.k);
+              }
+              tk.legend.mclass.hiddenvalues.delete(c.k);
+            }
+          },
+          {
+            label: "Show all",
+            isVisible: () => hiddenlst.length,
+            callback: () => {
+              tk.legend.mclass.hiddenvalues.clear();
+            }
+          },
+          {
+            isChangeShape: true,
+            isVisible: () => {
+              if (c.k == dtcnv) return false;
+              return !tk.skewer.viewModes.find((v) => v.type === "numeric")?.inuse ? tk.mds?.termdbConfig?.tracks?.allowSkewerChanges ?? true : false;
+            },
+            callback: (val, tk2) => {
+              tk2.shapes[c.k] = val;
+              tk2.load();
+              tk2.legend.tip.hide();
+            }
+          },
+          {
+            isChangeColor: true,
+            value: color,
+            isVisible: () => {
+              return c.k != dtcnv;
+            },
+            callback: (colorValue) => {
+              if (!mclass[c.k].origColor) mclass[c.k].origColor = mclass[c.k].color;
+              mclass[c.k].color = colorValue;
+            },
+            reset: {
+              isVisible: () => mclass[c.k].origColor,
+              callback: () => mclass[c.k].color = mclass[c.k].origColor
+            }
+          }
+        ];
+        createLegendTipMenu(opts, tk, event.target);
+        const descDiv = tk.legend.tip.d.append("div").style("padding", "10px").style("font-size", ".8em").style("width", "150px");
+        descDiv.append("span").style("color", color).text(label.toUpperCase());
+        descDiv.append("div").style("color", "black").html(desc);
+      }
+    });
+  }
+  for (const c of hiddenlst) {
+    let loading = false;
+    tk.legend.mclass.holder.append("div").style("display", "inline-block").attr("class", "sja_clb").style("text-decoration", "line-through").style("opacity", 0.7).text((c.count ? "(" + c.count + ") " : "") + (Number.isInteger(c.k) ? dt2label[c.k] : mclass[c.k].label)).on("click", async (event2) => {
+      if (loading) return;
+      loading = true;
+      tk.legend.mclass.hiddenvalues.delete(c.k);
+      event2.target.innerHTML = "Updating...";
+      await tk.load();
+    });
+  }
+}
+function may_create_skewerRim(tk, block) {
+  if (!tk.mds.queries?.snvindel?.skewerRim) return;
+  const R = tk.legend.skewerRim = {};
+  if (!tk.mds.queries.snvindel.skewerRim.hiddenvaluelst) tk.mds.queries.snvindel.skewerRim.hiddenvaluelst = [];
+  R.row = tk.legend.table.append("tr");
+  R.headerTd = R.row.append("td").style("text-align", "right").style("opacity", 0.7);
+  R.holder = R.row.append("td");
+}
+function getSkewerRimLegendHeaderName(tk) {
+  const sk = tk.mds.queries.snvindel.skewerRim;
+  if (sk.type == "format") {
+    if (!sk.formatKey) throw "skewerRim.formatKey missing";
+    return tk.mds.bcf?.format?.[sk.formatKey]?.Description || sk.formatKey;
+  }
+  return "unknown skewerRim.type";
+}
+function may_update_skewerRim(data, tk) {
+  if (!data.skewer) return;
+  const sk = tk.mds.queries?.snvindel?.skewerRim;
+  if (!sk) return;
+  let rim1total = 0, noRimTotal = 0;
+  for (const m of data.skewer) {
+    const r1 = m.rim1count || 0;
+    rim1total += r1;
+    noRimTotal += m.occurrence - r1;
+  }
+  const R = tk.legend.skewerRim;
+  R.headerTd.text(getSkewerRimLegendHeaderName(tk));
+  R.holder.selectAll("*").remove();
+  if (rim1total > 0) {
+    R.holder.append("div").attr("class", "sja_clb").style("display", "inline-block").html(`${getRimSvg(1)}${sk.rim1value}, n=${rim1total}`).on("click", (event2) => {
+      tk.legend.tip.clear().showunder(event2.target).d.append("div").attr("class", "sja_menuoption").text("Hide").on("click", () => {
+        sk.hiddenvaluelst.push(sk.rim1value);
+        reload(tk);
+      });
+    });
+  }
+  if (noRimTotal > 0) {
+    R.holder.append("div").attr("class", "sja_clb").style("display", "inline-block").html(`${getRimSvg()}${sk.noRimValue}, n=${noRimTotal}`).on("click", (event2) => {
+      tk.legend.tip.clear().showunder(event2.target).d.append("div").attr("class", "sja_menuoption").text("Hide").on("click", () => {
+        sk.hiddenvaluelst.push(sk.noRimValue);
+        reload(tk);
+      });
+    });
+  }
+  for (const c of sk.hiddenvaluelst) {
+    let loading = false;
+    R.holder.append("div").style("display", "inline-block").attr("class", "sja_clb").style("text-decoration", "line-through").style("opacity", 0.7).text(c).on("click", async (event2) => {
+      if (loading) return;
+      loading = true;
+      sk.hiddenvaluelst.splice(sk.hiddenvaluelst.indexOf(c), 1);
+      event2.target.innerHTML = "Updating...";
+      await tk.load();
+    });
+  }
+}
+function getRimSvg(rim) {
+  return '<svg width="19" height="19" style="margin-right: 5px;"><circle cx="7" cy="12" r="7" fill="#b1b1b1"></circle>' + (rim == 1 ? '<path d="M6.735557395310443e-16,-11A11,11 0 0,1 11,0L9,0A9,9 0 0,0 5.51091059616309e-16,-9Z" transform="translate(7,12)" fill="#858585" stroke="none"></path>' : rim == 2 ? "" : "") + // blank for no rim
+  "</svg>";
+}
+function may_create_ld(tk, block) {
+  if (!tk.mds.queries?.ld) return;
+  tk.mds.queries.ld.colorScale = rgb_default(tk.mds.queries.ld.overlay.color_0, tk.mds.queries.ld.overlay.color_1);
+  const R = tk.legend.ld = {};
+  R.row = tk.legend.table.append("tr");
+  R.headerTd = R.row.append("td").style("text-align", "right").style("opacity", 0.7);
+  R.holder = R.row.append("td");
+  R.showHolder = R.holder.append("div").style("display", "none");
+  showLDlegend(R.showHolder, tk.mds.queries.ld.colorScale);
+  R.showHolder.append("span").text("Cancel overlay").style("font-size", ".7em").attr("class", "sja_clbtext").on("click", () => {
+    delete tk.mds.queries.ld.mOverlay;
+    if (tk.skewer?.hlssmid) delete tk.skewer.hlssmid;
+    tk.load();
+  });
+}
+function may_update_ld(tk) {
+  if (!tk.mds.queries?.ld?.mOverlay) {
+    if (tk.legend.ld) {
+      tk.legend.ld.headerTd.html("");
+      tk.legend.ld.showHolder.style("display", "none");
+    }
+    return;
+  }
+  tk.legend.ld.headerTd.html(tk.mds.queries.ld.mOverlay.ldtkname + " LD r<sup>2</sup>");
+  tk.legend.ld.showHolder.style("display", "block");
+}
+function may_create_cnv(tk, block) {
+  if (!tk.cnv) return;
+  const R = tk.legend.cnv = {};
+  R.row = tk.legend.table.append("tr");
+  R.headerTd = R.row.append("td").style("text-align", "right").style("opacity", 0.7).text("CNV");
+  R.holder = R.row.append("td").style("padding-left", "10px");
+  if (Number.isFinite(tk.cnv.cnvGainCutoff)) {
+    R.colorscaleHolder = R.holder.append("div");
+    R.colorscaleHolder.append("span").text("Loss").style("font-size", ".8em").style("opacity", 0.6);
+    const csHolder = R.colorscaleHolder.append("span");
+    R.colorscaleHolder.append("span").text("Gain").style("font-size", ".8em").style("opacity", 0.6);
+    const axisheight = 20;
+    const barheight = 15;
+    const xpad = 10;
+    const axiswidth = 150;
+    R.colorScale = new ColorScale({
+      barwidth: axiswidth,
+      barheight,
+      colors: [tk.cnv.lossColor, "white", tk.cnv.gainColor],
+      domain: [-1, 0, 1],
+      // actual domain added during update
+      fontSize: 12,
+      holder: csHolder,
+      height: axisheight + barheight,
+      width: xpad * 2 + axiswidth,
+      position: `${xpad},${axisheight}`,
+      ticks: 4,
+      tickSize: 6,
+      topTicks: true,
+      numericInputs: {
+        callback: (obj) => {
+          if (obj.cutoffMode == "auto") {
+            delete tk.cnv.presetMax;
+          } else if (obj.cutoffMode == "fixed") {
+            tk.cnv.presetMax = Math.abs(obj.max);
+          } else {
+            throw "unknown cutoffMode value";
+          }
+          tk.load();
+        }
+      }
+    });
+  } else {
+    R.cnvCategoryHolder = R.holder.append("span").attr("data-testid", "sjpp-mds3cnvlegend-categoryholder");
+  }
+  R.noCnv = R.holder.append("div").text("No data").style("opacity", 0.6);
+  const menu = new Menu();
+  R.cnvFilterPrompt = R.holder.append("div").style("display", "inline-block").style("margin-left", "10px").style("font-size", ".9em").attr("class", "sja_clbtext").on("click", () => {
+    menu.clear().showunder(R.cnvFilterPrompt.node());
+    const arg = {
+      holder: menu.d.append("div"),
+      cnvGainCutoff: tk.cnv.cnvGainCutoff,
+      cnvLossCutoff: tk.cnv.cnvLossCutoff,
+      cnvMaxLength: tk.cnv.cnvMaxLength,
+      callback: (config) => {
+        Object.assign(tk.cnv, config);
+        menu.hide();
+        tk.load();
+      }
+    };
+    renderCnvConfig(arg);
+  });
+}
+function may_update_cnv(tk) {
+  if (!tk.cnv) return;
+  if (!tk.cnv.cnvLst || tk.cnv.cnvLst.length == 0) {
+    tk.legend.cnv.colorscaleHolder?.style("display", "none");
+    tk.legend.cnv.cnvCategoryHolder?.style("display", "none");
+    tk.legend.cnv.noCnv.style("display", tk.cnv.cnvInDensity ? "none" : "inline-block");
+  } else {
+    tk.legend.cnv.noCnv.style("display", "none");
+    if (Number.isFinite(tk.cnv.cnvGainCutoff)) {
+      tk.legend.cnv.colorscaleHolder.style("display", "inline-block");
+      tk.legend.cnv.colorScale.colors = [tk.cnv.lossColor, "white", tk.cnv.gainColor];
+      tk.legend.cnv.colorScale.domain = tk.cnv.presetMax ? [-tk.cnv.presetMax, 0, tk.cnv.presetMax] : [-tk.cnv.absoluteMax, 0, tk.cnv.absoluteMax];
+      tk.legend.cnv.colorScale.updateScale();
+    } else {
+      if (!tk.hardcodeCnvOnly) {
+      } else {
+        tk.legend.cnv.cnvCategoryHolder.style("display", "inline-block").selectAll("*").remove();
+        const class2count = /* @__PURE__ */ new Map();
+        for (const c of tk.cnv.cnvLst) {
+          if (!c.class) continue;
+          class2count.set(c.class, 1 + (class2count.get(c.class) || 0));
+        }
+        for (const [cls, count] of [...class2count].sort((i, j) => j[1] - i[1])) {
+          printCategory({
+            holder: tk.legend.cnv.cnvCategoryHolder,
+            key: cls,
+            label: mclass[cls].label,
+            color: mclass[cls].color,
+            count,
+            click: (event2) => {
+              const opts = [
+                {
+                  label: "Hide",
+                  isVisible: () => true,
+                  callback: () => {
+                    tk.legend.mclass.hiddenvalues.add(cls);
+                  }
+                },
+                {
+                  isChangeColor: true,
+                  value: mclass[cls].color,
+                  isVisible: () => true,
+                  callback: (colorValue) => {
+                    if (!mclass[cls].origColor) mclass[cls].origColor = mclass[cls].color;
+                    mclass[cls].color = colorValue;
+                  },
+                  reset: {
+                    isVisible: () => mclass[cls].origColor,
+                    callback: () => mclass[cls].color = mclass[cls].origColor
+                  }
+                }
+              ];
+              createLegendTipMenu(opts, tk, event2.target);
+            }
+          });
+        }
+        for (const cls of tk.legend.mclass.hiddenvalues) {
+          let loading = false;
+          tk.legend.cnv.cnvCategoryHolder.append("div").style("display", "inline-block").attr("class", "sja_clb").style("text-decoration", "line-through").style("opacity", 0.7).text(mclass[cls].label).on("click", async (event2) => {
+            if (loading) return;
+            loading = true;
+            tk.legend.mclass.hiddenvalues.delete(cls);
+            event2.target.innerHTML = "Updating...";
+            await tk.load();
+          });
+        }
+      }
+    }
+  }
+  const lst = [];
+  if (Number.isFinite(tk.cnv.cnvGainCutoff)) {
+    lst.push(`CNV gain \u2265 ${tk.cnv.cnvGainCutoff}`);
+  }
+  if (Number.isFinite(tk.cnv.cnvLossCutoff)) {
+    lst.push(`CNV loss \u2264 ${tk.cnv.cnvLossCutoff}`);
+  }
+  if (Number.isFinite(tk.cnv.cnvMaxLength)) {
+    lst.push(`CNV length \u2264 ${bplen(tk.cnv.cnvMaxLength)}`);
+  } else {
+    lst.push("no length limit");
+  }
+  tk.legend.cnv.cnvFilterPrompt.text(`Filter: ${lst.join("; ")}`);
+}
+function createLegendTipMenu(opts, tk, elem) {
+  tk.legend.tip.clear().showunder(elem);
+  for (const opt of opts) {
+    if (opt.isVisible()) {
+      if (opt.isChangeColor) {
+        tk.legend.tip.d.append("div").style("padding", "5px 10px").style("display", "inline-block").text("Color:").append("input").attr("type", "color").property("value", rgb(opt.value).formatHex()).on("change", (event2) => {
+          const color = event2.target.value;
+          opt.callback(color);
+          reload(tk);
+        });
+        if (opt.reset && opt.reset?.isVisible()) {
+          const resetDiv = tk.legend.tip.d.append("div").style("display", "inline-block");
+          const handler = () => {
+            opt.reset.callback();
+            reload(tk);
+          };
+          icons["restart"](resetDiv, { handler, title: "Reset to original color" });
+        }
+      } else if (opt.isChangeShape) {
+        let called = false;
+        const div = tk.legend.tip.d.append("div").text("Change shape").style("vertical-align", "middle").classed("sja_menuoption", true).style("padding", "5px 10px").style("margin", "1px").style("border-radius", "0px").on("click", () => {
+          div.classed("sja_menuoption", false);
+          div.style("background-color", "white");
+          if (called == false) {
+            called = true;
+            renderShapePicker({
+              holder: div.append("div").style("margin-top", "10px"),
+              callback: (val) => opt.callback(val, tk),
+              tk
+            });
+          }
+        });
+      } else {
+        tk.legend.tip.d.append("div").attr("class", "sja_menuoption").style("border-radius", "0px").text(opt.label).on("click", () => {
+          opt.callback();
+          reload(tk);
+        });
+      }
+    }
+  }
+}
+function printCategory({ holder, key, color, count, label, click }) {
+  const div = holder.append("div").attr("class", "sja_clb").style("display", "inline-block").on("click", click);
+  div.append("div").style("display", "inline-block").attr("class", "sja_mcdot").style("background", color).html(count > 1 ? count : "&nbsp;");
+  div.append("div").style("display", "inline-block").style("color", color).style("padding-left", "5px").attr("data-testid", "sjpp-mds3tk-legenditemlabel").attr("__key__", key).text(label);
+}
+
+// mds3/filterName.js
+function getFilterName(f) {
+  if (!Array.isArray(f?.lst)) return "Invalid filter";
+  const lst = f.lst.filter((i) => i.tag != "cohortFilter");
+  if (lst.length == 0) return "No filter";
+  if (lst.length == 1 && lst[0].type == "tvs") {
+    const tvs = lst[0].tvs;
+    if (!tvs) throw "f.lst[0].tvs{} missing";
+    switch (tvs?.term?.type) {
+      case "categorical":
+        if (!Array.isArray(tvs.values)) throw "f.lst[0].tvs.values not array";
+        const catKey = tvs.values[0]?.key;
+        if (catKey == void 0) throw "f.lst[0].tvs.values[0].key missing";
+        const catValue = tvs.term.values?.[catKey]?.label || catKey;
+        if (tvs.values.length == 1) {
+          if ((tvs.term.name + catValue).length < 20) {
+            return tvs.term.name + (tvs.isnot ? "!=" : ": ") + catValue;
+          }
+          return (tvs.isnot ? "!" : "") + (catValue.length < 15 ? catValue : catValue.substring(0, 13) + "...");
+        }
+        return `${tvs.isnot ? "!" : ""}${catValue.length < 12 ? catValue : catValue.substring(0, 10) + "..."} (${tvs.values.length})`;
+      case "integer":
+      case "float":
+      case "geneExpression":
+      case "metaboliteIntensity":
+      case "proteomeAbundance":
+        return getNumericRangeLabel(tvs);
+      case "samplelst":
+        return Object.keys(tvs.term.values)[0];
+      default:
+        for (const dtt of dtTerms) {
+          if (dtt.type == tvs.term.type) {
+            return (tvs.term.parentTerm?.name || "?") + " " + dtt.name;
+          }
+        }
+        throw "unknown tvs term type";
+    }
+  }
+  return "Filter (" + lst.length + ")";
+}
+function getNumericRangeLabel(tvs) {
+  if (!Array.isArray(tvs.ranges)) throw "tvs.ranges not array";
+  if (!tvs.ranges[0]) throw "tvs.ranges[] blank array";
+  const r = tvs.ranges[0];
+  let startName, stopName;
+  const vc = tvs.term.valueConversion;
+  if (vc) {
+    if ("start" in r) startName = convertUnits(r.start, vc.fromUnit, vc.toUnit, vc.scaleFactor, true);
+    if ("stop" in r) stopName = convertUnits(r.stop, vc.fromUnit, vc.toUnit, vc.scaleFactor, true);
+  } else {
+    if (tvs.term.type == "integer") {
+      if ("start" in r) startName = Math.round(r.start);
+      if ("stop" in r) stopName = Math.round(r.stop);
+    } else {
+      if ("start" in r) startName = r.start;
+      if ("stop" in r) stopName = r.stop;
+      if ("start" in r && "stop" in r) {
+        ;
+        [startName, stopName] = niceNumLabels([startName, stopName]);
+      }
+    }
+  }
+  let label;
+  if (tvs.isnot) {
+    if (r.startunbounded) label = `x ${r.stopinclusive ? ">" : ">="} ${stopName}`;
+    else if (r.stopunbounded) label = `x ${r.startinclusive ? "<" : "<="} ${startName}`;
+    else label = `!(${startName} ${stopName})`;
+  } else {
+    if (r.startunbounded) label = `x ${r.stopinclusive ? "<=" : "<"} ${stopName}`;
+    else if (r.stopunbounded) label = `x ${r.startinclusive ? ">=" : ">"} ${startName}`;
+    else label = `${startName}${r.startinclusive ? "<=" : "<"}x${r.stopinclusive ? "<=" : "<"}${stopName}`;
+  }
+  if (tvs.ranges.length > 1) label += "...";
+  return label;
+}
+
+// mds3/makeTk.js
+var callbacknames = [
+  "onClose",
+  // this only takes effect if tk shows the "Close" handle, e.g. on subtk
+  "click_snvindel",
+  "callbackOnRender",
+  "disc_mouseover",
+  "disc_mouseout"
+];
+async function makeTk(tk, block) {
+  tk.subtk2height = {
+    skewer: 0,
+    leftlabels: 0,
+    cnv: 0
+  };
+  tk.leftlabels = {
+    g: tk.gleft.append("g"),
+    // all labels are rendered here, except track label
+    doms: {},
+    // keys: label name, value: label dom
+    // to avoid having to delete all labels upon tk rendering
+    laby: 0,
+    // cumulative height, 0 for no labels
+    xoff: 0,
+    maxwidth: 0
+    // set default 0 in case track runs into err, can still render tk
+  };
+  tk._finish = loadTk_finish_closure(tk, block);
+  tk.cache = {};
+  tk.itemtip = new Menu();
+  tk.hovertip = new Menu();
+  tk.menutip = new Menu({ padding: "" });
+  tk.load = _load(tk, block);
+  tk.mnamegetter = (m) => {
+    if (tk.mds.queries?.snvindel?.vcfid4skewerName && m.vcf_id) return m.vcf_id;
+    const s = m.mname;
+    if (!s) return "";
+    if (s.length > 25) {
+      return s.substr(0, 20) + "...";
+    }
+    return s;
+  };
+  await get_ds(tk, block);
+  await mayInitTermdb(tk, block);
+  await mayInit_variant2samples(tk, block);
+  mayaddGetter_m2csq(tk, block);
+  mayInitSkewer(tk);
+  mayInitCnv(tk);
+  if (tk.filterObj) await Promise.all(rehydrateFilter(tk.filterObj, tk.mds.termdb.vocabApi));
+  tk.tklabel.text(tk.mds.label || tk.name);
+  tk.clear = () => {
+    if (tk.skewer) tk.skewer.g.selectAll("*").remove();
+  };
+  initLegend(tk, block);
+  init_mclass(tk);
+  tk.color4disc = (m) => {
+    if (tk.mutationColorBy) {
+      if (tk.mutationColorBy == "hardcode") {
+        if (m.color) return m.color;
+      }
+    }
+    if (tk.mds.queries?.ld?.mOverlay?.data) {
+      const m0 = tk.mds.queries.ld.mOverlay.m;
+      if (m.chr == m0.chr && m.pos == m0.pos && m.ref == m0.ref && m.alt == m0.alt) {
+        return tk.mds.queries.ld.overlay.color_1;
+      }
+      for (const m1 of tk.mds.queries.ld.mOverlay.data) {
+        if (m1.pos == m.pos && m1.alleles == m.ref + "." + m.alt) {
+          return tk.mds.queries.ld.colorScale(m1.r2);
+        }
+      }
+      return tk.mds.queries.ld.overlay.color_0;
+    }
+    if (tk.vcfinfofilter && tk.vcfinfofilter.setidx4mclass != void 0) {
+      const mcset = tk.vcfinfofilter.lst[tk.vcfinfofilter.setidx4mclass];
+      const [err, vlst] = getter_mcset_key(mcset, m);
+      if (err || vlst == void 0) return "black";
+      for (const v of vlst) {
+        if (mcset.categories[v]) {
+          return mcset.categories[v].color;
+        } else {
+          return "black";
+        }
+      }
+    }
+    if (mclass[m.class]) {
+      return mclass[m.class].color;
+    }
+    return "black";
+  };
+  parseUrl(tk);
+  if (tk.hlssmid) {
+    tk.skewer.hlssmid = new Set(tk.hlssmid.split(","));
+    delete tk.hlssmid;
+  }
+  try {
+    validateSelectSamples(tk);
+  } catch (e) {
+    console.error(e);
+  }
+  tk.duplicateTk = (filter) => {
+    const tkarg = {
+      type: "mds3",
+      dslabel: tk.dslabel,
+      filter0: tk.filter0,
+      showCloseLeftlabel: true,
+      filterObj: filter || structuredClone(tk.filterObj),
+      allow2selectSamples: tk.allow2selectSamples,
+      onClose: tk.onClose,
+      callbackOnRender: tk.callbackOnRender,
+      hardcodeCnvOnly: tk.hardcodeCnvOnly,
+      token: tk.token
+      // for testing
+    };
+    if (tk.cnv?.presetMax) tkarg.cnv = { presetMax: tk.cnv.presetMax };
+    if (tk.legend.mclass?.hiddenvalues?.size) {
+      tkarg.legend = { mclass: { hiddenvalues: /* @__PURE__ */ new Set() } };
+      for (const v of tk.legend.mclass.hiddenvalues) tkarg.legend.mclass.hiddenvalues.add(v);
+    }
+    return tkarg;
+  };
+  for (const n of callbacknames) {
+    if (tk[n] && typeof tk[n] != "function") throw `.${n}() is not function`;
+  }
+}
+function loadTk_finish_closure(tk, block) {
+  return (data) => {
+    tk.legend?.headTd.text(tk.name + (tk.filterObj ? " - " + getFilterName(tk.filterObj) : ""));
+    if (tk.cnv) {
+      tk.cnv.g.transition().attr("transform", `translate(0,${tk.subtk2height.skewer})`);
+    }
+    if (data) {
+      if (data.error) {
+        tk.subtk2height.skewer = 40;
+      } else {
+        let totalCount = 0;
+        if (data.skewer) totalCount = data.skewer.length;
+        if (data.cnv) totalCount += data.cnv.length;
+        if (data.cnvDensity) totalCount += data.cnvDensity.segmentCount;
+        if (totalCount == 0) {
+          let context = "view range";
+          if (block.usegm && block.gmmode != "genomic") context = block.usegm.name || block.usegm.isoform;
+          tk.skewer.g.append("text").text("No data in " + context).attr("y", 25).attr("x", block.width / 2).attr("text-anchor", "middle").attr("dominant-baseline", "center");
+          tk.subtk2height.skewer = 40;
+        }
+      }
+    }
+    tk.height_main = Math.max(
+      tk.subtk2height.leftlabels,
+      // won't be added if tk crashed
+      tk.subtk2height.skewer + tk.subtk2height.cnv
+    ) + tk.toppad + tk.bottompad;
+    if (data) {
+      updateLegend(data, tk, block);
+    }
+    tk.leftLabelMaxwidth = Math.max(
+      tk.leftlabels.maxwidth + tk.leftlabels.xoff,
+      // tk.skewer.maxwidth is undefined if makeTk had exception. must yield valid value for leftLabelMaxwidth for block to show properly with err msg in tk body
+      Number.isFinite(tk.skewer?.maxwidth) ? tk.skewer.maxwidth : 0
+    );
+    block.tkcloakoff(tk, { error: data ? data.error : null });
+    block.block_setheight();
+    block.setllabel();
+    tk.callbackOnRender?.(tk, block);
+  };
+}
+function parseUrl(tk) {
+  const urlp = urlmap_default();
+  if (tk.skewer) {
+    if (urlp.has("hlaachange")) {
+      tk.hlaachange = urlp.get("hlaachange");
+    }
+    if (urlp.has("hlssmid")) {
+      tk.hlssmid = urlp.get("hlssmid").split(",");
+    }
+  }
+}
+function mayInitSkewer(tk) {
+  if (!tk.mds.has_skewer) return;
+  tk.skewer = {
+    // both skewer and numeric mode will render elements into tk.skewer.g
+    // will also attach skewer.discKickSelection
+    g: tk.glider.append("g"),
+    // border color of a box over a highlighted data
+    hlBoxColor: tk.mds.hlBoxColor || "red",
+    // default to show dot labels
+    hideDotLabels: false,
+    // true for pointing up
+    pointup: true
+  };
+  setSkewerMode(tk);
+}
+function mayInitCnv(tk) {
+  let cfg;
+  if (tk.mds.termdbConfig?.queries?.cnv) {
+    cfg = tk.mds.termdbConfig.queries.cnv;
+  } else if (tk.custom_variants?.find((i) => i.dt == dtcnv)) {
+    let useValue = false, useCat = false;
+    for (const m of tk.custom_variants) {
+      if (m.dt == dtcnv) {
+        if (Number.isFinite(m.value)) useValue = true;
+        else useCat = true;
+      }
+    }
+    if (useValue && useCat) throw "custom cnv should be either using numeric value or not, but cannot be mixture";
+    if (useValue) {
+      cfg = {
+        cnvGainCutoff: 0,
+        // use 0 for not filtering and show all events
+        cnvLossCutoff: 0
+      };
+    } else if (useCat) {
+      cfg = {};
+    } else {
+      throw "custom cnv is neither value or category, should not happen";
+    }
+  } else {
+    return;
+  }
+  if (!tk.cnv) tk.cnv = {};
+  tk.cnv.g = tk.glider.append("g");
+  tk.cnv.cnvMaxLength = cfg.cnvMaxLength;
+  tk.cnv.cnvGainCutoff = cfg.cnvGainCutoff;
+  tk.cnv.cnvLossCutoff = cfg.cnvLossCutoff;
+  tk.cnv.absoluteValueRenderMax = cfg.absoluteValueRenderMax || 5;
+  tk.cnv.gainColor = cfg.gainColor || "#D6683C";
+  tk.cnv.lossColor = cfg.lossColor || "#67a9cf";
+  tk.cnv.density = {
+    barheight: 60
+  };
+}
+function setSkewerMode(tk) {
+  tk.skewer.viewModes = tk.skewerModes;
+  delete tk.skewerModes;
+  if (!tk.skewer.viewModes) tk.skewer.viewModes = [];
+  const vm = tk.skewer.viewModes;
+  if (!Array.isArray(vm)) throw "skewerModes[] is not array";
+  if (tk.mds.skewerModes) {
+    for (const n of tk.mds.skewerModes) vm.push(n);
+  }
+  if (!vm.find((n) => n.type == "skewer")) vm.push({ type: "skewer" });
+  for (const n of vm) {
+    if (typeof n != "object") throw "one of skewerModes[] is not object";
+    if (n.type == "skewer") {
+      if (!n.label) n.label = "lollipops";
+    } else if (n.type == "numeric") {
+      if (n.byAttribute) {
+        if (!n.label) n.label = n.byAttribute;
+      } else if (n.byInfo) {
+      } else {
+        throw "unknown data method for a type=numeric mode";
+      }
+    } else {
+      throw "unknown type from a skewerModes[]";
+    }
+  }
+  if (!vm.find((n) => n.inuse)) vm[0].inuse = true;
+}
+function init_mclass(tk) {
+  if (tk.mds.hiddenmclass) {
+    for (const c of tk.mds.hiddenmclass) tk.legend.mclass.hiddenvalues.add(c);
+  }
+}
+async function get_ds(tk, block) {
+  if (tk.dslabel) {
+    const data = await dofetch3("getDataset", { body: { genome: block.genome.name, dsname: tk.dslabel } });
+    if (data.error) throw "Error: " + data.error;
+    if (!data.ds) throw "data.ds{} missing";
+    if (!data.ds.isMds3) throw "A legacy dataset cannot be loaded as a mds3 track";
+    tk.mds = data.ds;
+    tk.name = data.ds.label;
+    return;
+  }
+  if (!tk.name) tk.name = "Custom data";
+  tk.mds = {};
+  if (tk.bcf) {
+    if (!tk.bcf.file && !tk.bcf.url) throw "file or url missing for tk.bcf{}";
+    tk.mds.has_skewer = true;
+    await getbcfheader_customtk(tk, block.genome);
+  } else if (tk.custom_variants) {
+    validateCustomVariants(tk, block);
+    mayDeriveSkewerOccurrence4samples(tk);
+    mayAddInfoField(tk);
+  } else {
+    throw "unknown data source for custom track";
+  }
+  mayProcessSampleAnnotation(tk);
+}
+function mayProcessSampleAnnotation(tk) {
+  if (!tk.sampleAnnotation) return;
+  if (!Array.isArray(tk.sampleAnnotation.terms)) throw "sampleAnnotation.terms is not array";
+  if (!tk.mds.termdb) tk.mds.termdb = {};
+  tk.mds.termdb.terms = tk.sampleAnnotation.terms;
+  tk.mds.termdb.annotations = tk.sampleAnnotation.annotations;
+}
+async function mayInitTermdb(tk, block) {
+  const tdb = tk.mds.termdb;
+  if (!tdb) return;
+  {
+    const arg = {};
+    if (tk.mds.label) {
+      arg.vocab = {
+        genome: block.genome.name,
+        dslabel: tk.mds.label
+      };
+    } else if (tdb.terms) {
+      arg.vocab = {
+        terms: tdb.terms,
+        sampleannotation: tdb.annotations
+      };
+    } else {
+      throw "do not know how to init vocab";
+    }
+    const _ = await import("./vocabulary-ELXLTPKE.js");
+    tdb.vocabApi = _.vocabInit(arg);
+    if (!tdb.vocabApi.app) {
+      tdb.vocabApi.app = { opts: { genome: block.genome } };
+    }
+  }
+  tk.mds.termdbConfig = await tdb.vocabApi.getTermdbConfig();
+  if (tk.mds.termdb.allowCaseDetails) {
+    tk.mds.termdb.allowCaseDetails.get = async (acase) => {
+    };
+  }
+}
+function mayaddGetter_m2csq(tk, block) {
+  if (!tk.mds.queries?.snvindel?.m2csq) return;
+  tk.mds.queries.snvindel.m2csq.get = async (m) => {
+    const body = { genome: block.genome.name, dslabel: tk.mds.label, m2csq: 1 };
+    if (tk.mds.queries.snvindel.m2csq.by == "ssm_id") {
+      body.ssm_id = m.ssm_id;
+    } else {
+      return { error: "unknown query method" };
+    }
+    const headers = { "Content-Type": "application/json", Accept: "application/json" };
+    if (tk.token) headers["X-Auth-Token"] = tk.token;
+    return await dofetch3("mds3", { body, headers }, { serverData: tk.cache });
+  };
+}
+async function mayInit_variant2samples(tk, block) {
+  if (!tk.mds.variant2samples) return;
+  if (tk.custom_variants) {
+    addV2Sgetter_custom(tk, block);
+  } else {
+    addV2Sgetter_native(tk, block);
+  }
+  if (tk.mds.variant2samples.twLst) {
+    if (!Array.isArray(tk.mds.variant2samples.twLst)) throw "v2s.twLst[] not array";
+    if (!tk.mds.termdb?.vocabApi) throw "mds.termdb.vocabApi should be present for initiating v2s.twLst";
+    for (const t of tk.mds.variant2samples.twLst) await fillTermWrapper(t, tk.mds.termdb.vocabApi);
+  }
+}
+function addV2Sgetter_custom(tk, block) {
+  tk.mds.variant2samples.get = (arg) => {
+    if (arg.querytype == tk.mds.variant2samples.type_samples) {
+      const samples = [];
+      for (const m of arg.mlst) {
+        if (!m.samples) continue;
+        for (const s of m.samples) {
+          const s2 = JSON.parse(JSON.stringify(s));
+          s2.ssm_id = m.ssm_id;
+          samples.push(s2);
+        }
+      }
+      return { samples };
+    }
+    if (arg.querytype == tk.mds.variant2samples.type_summary) {
+      throw "todo: summary";
+    }
+    if (arg.querytype == tk.mds.variant2samples.type_sunburst) {
+      throw "todo: sunburst";
+    }
+    throw "unknown querytype";
+  };
+  tk.mds.getSamples = () => {
+    const id2sample = /* @__PURE__ */ new Map();
+    for (const m of tk.custom_variants) {
+      if (!m.samples) continue;
+      for (const s of m.samples) {
+        if (id2sample.has(s.sample_id)) {
+          id2sample.get(s.sample_id).ssm_id_lst.push(m.ssm_id);
+        } else {
+          const s2 = JSON.parse(JSON.stringify(s));
+          s2.ssm_id_lst = [m.ssm_id];
+          id2sample.set(s.sample_id, s2);
+        }
+      }
+    }
+    return { samples: [...id2sample.values()] };
+  };
+}
+function addV2Sgetter_native(tk, block) {
+  tk.mds.variant2samples.get = async (arg) => {
+    const par = {
+      genome: block.genome.name,
+      variant2samples: 1,
+      get: arg.querytype,
+      hardcodeCnvOnly: tk.hardcodeCnvOnly
+    };
+    if (tk.cnv) {
+      if (tk.cnv.cnvMaxLength) par.cnvMaxLength = tk.cnv.cnvMaxLength;
+      if (tk.cnv.cnvGainCutoff) par.cnvGainCutoff = tk.cnv.cnvGainCutoff;
+      if (tk.cnv.cnvLossCutoff) par.cnvLossCutoff = tk.cnv.cnvLossCutoff;
+    }
+    if (tk.mds.label) {
+      par.dslabel = tk.mds.label;
+    } else if (tk.bcf) {
+      if (tk.bcf.file) par.bcffile = tk.bcf.file;
+      else if (tk.bcf.url) par.bcfurl = tk.bcf.url;
+      else throw "tk.bcf{}: file/url missing";
+    } else {
+      throw "no dslabel or tk.bcf";
+    }
+    if (arg.groupSsmBySample) {
+      par.groupSsmBySample = 1;
+    }
+    if (arg.mlst) {
+      if (tk.mds.variant2samples.variantkey == "ssm_id") {
+        par.ssm_id_lst = arg.mlst.map((i) => i.ssm_id).join(",");
+      } else {
+        throw "unknown variantkey for variant2samples";
+      }
+    }
+    if (arg.isoform) {
+      par.isoform = arg.isoform;
+    }
+    if (arg.rglst) {
+      par.rglst = arg.rglst;
+    }
+    const headers = { "Content-Type": "application/json", Accept: "application/json" };
+    if (tk.set_id) par.set_id = tk.set_id;
+    if (tk.token) headers["X-Auth-Token"] = tk.token;
+    if (tk.filter0) par.filter0 = tk.filter0;
+    if (tk.filterObj) par.filterObj = tk.filterObj;
+    if (arg.tid2value) par.tid2value = arg.tid2value;
+    if (arg.querytype == tk.mds.variant2samples.type_sunburst) {
+      if (tk.mds.variant2samples.sunburst_twLst) {
+        par.twLst = tk.mds.variant2samples.sunburst_twLst;
+      }
+    } else if (arg.querytype == tk.mds.variant2samples.type_samples) {
+      if (tk.mds.variant2samples.twLst) par.twLst = tk.mds.variant2samples.twLst;
+    } else if (arg.querytype == tk.mds.variant2samples.type_summary) {
+      if (tk.mds.variant2samples.twLst) par.twLst = tk.mds.variant2samples.twLst;
+    } else {
+      throw "unknown querytype";
+    }
+    par.skewerRim = tk.mds.queries.snvindel?.skewerRim;
+    if (tk.legend?.formatFilter) {
+      const filter = {};
+      for (const k in tk.legend.formatFilter) {
+        if (tk.legend.formatFilter[k].hiddenvalues.size) {
+          filter[k] = [...tk.legend.formatFilter[k].hiddenvalues];
+        }
+      }
+      if (Object.keys(filter).length) {
+        par.formatFilter = filter;
+      }
+    }
+    if (tk.legend?.mclass?.hiddenvalues?.size) {
+      par.hiddenmclasslst = JSON.stringify([...tk.legend.mclass.hiddenvalues]);
+    }
+    const data = await dofetch3("mds3", { body: par, headers }, { serverData: tk.cache });
+    if (data.error) throw data.error;
+    const r = data.variant2samples;
+    if (!r) throw "result error";
+    if (arg.querytype == tk.mds.variant2samples.type_sunburst) {
+      if (!Array.isArray(r.nodes)) throw "nodes[] not array from return";
+    } else if (arg.querytype == tk.mds.variant2samples.type_samples) {
+      if (!Array.isArray(r.samples)) throw "samples[] not array from return";
+    } else if (arg.querytype == tk.mds.variant2samples.type_summary) {
+      if (!Array.isArray(r.summary)) throw "summary[] not array from return";
+    } else {
+      throw "unknown querytype";
+    }
+    return r;
+  };
+  tk.mds.getSamples = async (arg = {}) => {
+    if (arg.isSummary) {
+      arg.querytype = tk.mds.variant2samples.type_summary;
+    } else {
+      arg.querytype = tk.mds.variant2samples.type_samples;
+      arg.groupSsmBySample = 1;
+    }
+    rangequery_rglst(tk, block, arg);
+    return await tk.mds.variant2samples.get(arg);
+  };
+}
+function _load(tk, block) {
+  return async () => {
+    return await loadTk(tk, block);
+  };
+}
+function getter_mcset_key(mcset, m) {
+  if (mcset.altalleleinfo) {
+    if (!m.altinfo) return ["no .altinfo"];
+    const value = m.altinfo[mcset.altalleleinfo.key];
+    if (value == void 0) {
+      if (mcset.numericfilter) {
+        return [null, [0]];
+      }
+      return [null, void 0];
+    }
+    let vlst = Array.isArray(value) ? value : [value];
+    if (mcset.altalleleinfo.separator) {
+      vlst = vlst[0].split(mcset.altalleleinfo.separator);
+    }
+    return [null, vlst];
+  }
+  if (mcset.locusinfo) {
+    if (!m.info) return ["no .info"];
+    const value = m.info[mcset.locusinfo.key];
+    if (value == void 0) {
+      if (mcset.numericfilter) {
+        return [null, [0]];
+      }
+      return [null, void 0];
+    }
+    let vlst = Array.isArray(value) ? value : [value];
+    if (mcset.locusinfo.separator) {
+      vlst = vlst[0].split(mcset.locusinfo.separator);
+    }
+    return [null, vlst];
+  }
+  return ["no trigger"];
+}
+function validateCustomVariants(tk, block) {
+  for (const m of tk.custom_variants) {
+    if (m.dt == dtsnvindel) {
+      tk.mds.has_skewer = true;
+      validateCustomSnvindel(m);
+      continue;
+    }
+    if (m.dt == dtfusionrna || m.dt == dtsv) {
+      tk.mds.has_skewer = true;
+      validateCustomSvfusion(m, block);
+      continue;
+    }
+    if (m.dt == dtcnv) {
+      m.ssm_id = [m.chr, m.start, m.stop, m.class].join(ssmIdFieldsSeparator);
+      continue;
+    }
+    throw "unknown dt for a custom variant";
+  }
+}
+function validateCustomSnvindel(m) {
+  if (!m.chr) throw ".chr missing for custom snvindel";
+  if (!Number.isInteger(m.pos)) throw ".pos not integer for custom snvindel";
+  if (!m.ssm_id) {
+    m.ssm_id = [m.chr, m.pos, m.ref && m.alt ? m.ref + ssmIdFieldsSeparator + m.alt : m.mname].join(
+      ssmIdFieldsSeparator
+    );
+  }
+}
+function validateCustomSvfusion(m, block) {
+  if (m.pairlst) {
+  } else {
+    if (!m.chr1) throw ".chr1 missing for custom sv/fusion";
+    if (!Number.isInteger(m.pos1)) throw ".pos1 not integer for custom svfusion";
+    if (m.strand1 != "+" && m.strand1 != "-") throw ".strand1 not +/- for custom svfusion";
+    if (!m.chr2) throw ".chr1 missing for custom sv/fusion";
+    if (!Number.isInteger(m.pos2)) throw ".pos1 not integer for custom svfusion";
+    if (m.strand2 != "+" && m.strand2 != "-") throw ".strand1 not +/- for custom svfusion";
+    m.pairlst = [
+      {
+        a: {
+          chr: m.chr1,
+          pos: m.pos1,
+          strand: m.strand1,
+          name: m.gene1 || ""
+        },
+        b: {
+          chr: m.chr2,
+          pos: m.pos2,
+          strand: m.strand2,
+          name: m.gene2 || ""
+        }
+      }
+    ];
+    delete m.chr1;
+    delete m.pos1;
+    delete m.strand1;
+    delete m.gene1;
+    delete m.chr2;
+    delete m.pos2;
+    delete m.strand2;
+    delete m.gene2;
+  }
+  const fields = [m.dt];
+  const hits = block.seekcoord(m.pairlst[0].a.chr, m.pairlst[0].a.pos);
+  if (hits.length && hits[0].x > 0 && hits[0].x < block.width) {
+    fields.push(...[m.pairlst[0].a.chr, m.pairlst[0].a.pos, m.pairlst[0].a.strand, 0, m.pairlst[0].a.name]);
+    m.mname = m.pairlst[0].b.name || "";
+    m.chr = m.pairlst[0].a.chr;
+    m.pos = m.pairlst[0].a.pos;
+    m.pairlstIdx = 0;
+  } else {
+    const hits2 = block.seekcoord(m.pairlst[0].b.chr, m.pairlst[0].b.pos);
+    if (hits2.length && hits2[0].x > 0 && hits2[0].x < block.width) {
+      fields.push(...[m.pairlst[0].b.chr, m.pairlst[0].b.pos, m.pairlst[0].b.strand, 1, m.pairlst[0].b.name]);
+      m.mname = m.pairlst[0].a.name || "";
+      m.chr = m.pairlst[0].b.chr;
+      m.pos = m.pairlst[0].b.pos;
+      m.pairlstIdx = 1;
+    } else {
+    }
+  }
+  m.ssm_id = fields.join(ssmIdFieldsSeparator);
+}
+function mayDeriveSkewerOccurrence4samples(tk) {
+  if (tk.custom_variants.find((i) => i.occurrence != void 0)) {
+    return;
+  }
+  for (const i of tk.custom_variants) {
+    if (i.sample) {
+      i.sample_id = i.sample;
+      delete i.sample;
+    }
+  }
+  if (!tk.custom_variants.find((i) => i.sample_id)) {
+    return;
+  }
+  const ungrouped = [];
+  const key2m = /* @__PURE__ */ new Map();
+  for (const m of tk.custom_variants) {
+    if (m.dt != dtsnvindel) {
+      m.occurrence = 1;
+      m.samples = [{ sample_id: m.sample_id }];
+      delete m.sample_id;
+      ungrouped.push(m);
+      continue;
+    }
+    const key = [m.mname, m.chr, m.pos, m.ref, m.alt].join(ssmIdFieldsSeparator);
+    const m2 = key2m.get(key);
+    if (m2) {
+      m2.occurrence++;
+      m2.samples.push({
+        sample_id: m.sample_id
+      });
+    } else {
+      m.occurrence = 1;
+      m.samples = [
+        {
+          sample_id: m.sample_id
+        }
+      ];
+      delete m.sample_id;
+      key2m.set(key, m);
+    }
+  }
+  tk.custom_variants = ungrouped;
+  for (const m of key2m.values()) tk.custom_variants.push(m);
+  if (!tk.mds.variant2samples) tk.mds.variant2samples = {};
+  const v = tk.mds.variant2samples;
+  v.type_samples = "samples";
+  v.type_summary = "summary";
+  v.type_sunburst = "sunburst";
+}
+function mayAddInfoField(tk) {
+  if (!tk.custom_variants.some((i) => i.info)) return;
+  const info = {};
+  for (const m of tk.custom_variants) {
+    if (typeof m.info != "object") continue;
+    for (const k in m.info) {
+      const v = m.info[k];
+      if (v == null || v == void 0) continue;
+      if (!info[k]) info[k] = { ID: k, Number: ".", Type: "String", categories: {} };
+      if (!info[k].categories[v]) info[k].categories[v] = {};
+    }
+  }
+  for (const k in info) {
+    const colors = getColors(Object.keys(info[k].categories).length);
+    for (const c in info[k].categories) {
+      info[k].categories[c].color = colors(c);
+    }
+  }
+  tk.mds.bcf = { info };
+}
+async function getbcfheader_customtk(tk, genome) {
+  const arg = { genome: genome.name };
+  if (tk.bcf.file) {
+    arg.file = tk.bcf.file;
+  } else {
+    arg.url = tk.bcf.url;
+    if (tk.bcf.indexURL) arg.indexURL = tk.bcf.indexURL;
+  }
+  const data = await dofetch3("bcfheader", { body: arg });
+  if (data.error) throw data.error;
+  const [info, format2, samples, errs] = data.header;
+  if (errs) throw "Error parsing VCF meta lines: " + errs.join("; ");
+  tk.mds.bcf = {
+    info,
+    format: format2
+    // can be null
+  };
+  if (samples?.length) {
+    tk.mds.bcf.samples = samples;
+    tk.mds.variant2samples = {
+      //twLst:[], // TODO should not be required
+      type_samples: "samples",
+      variantkey: "ssm_id"
+    };
+  }
+  if (!tk.mds.queries) tk.mds.queries = {};
+  tk.mds.queries.snvindel = { forTrack: true };
+}
+function validateSelectSamples(tk) {
+  const a = tk.allow2selectSamples;
+  if (!a) return;
+  if (!a.buttonText) a.buttonText = "Select samples";
+  if (typeof a.buttonText != "string") throw "allow2selectSamples.buttonText value is not string";
+  if (!a.attributes) a.attributes = [{ from: "sample_id", to: "sample_id" }];
+  if (!Array.isArray(a.attributes)) throw "allow2selectSamples.attributes[] is not array";
+  if (a.attributes.length == 0) throw "allow2selectSamples.attributes[] blank array";
+  for (const i of a.attributes) {
+    if (typeof i.from != "string" || !i.from) throw "allow2selectSamples.attributes.from is not string";
+    if (typeof i.to != "string" || !i.to) throw "allow2selectSamples.attributes.to is not string";
+  }
+  if (typeof a.callback != "function") throw "allow2selectSamples.callback() is not function";
+  a._cart = [];
+}
+
+// mds3/cnv.js
+var maxRowHeight = 10;
+var maxTkHeight = 200;
+function getRowHeight(rows, tk) {
+  let maxh = maxTkHeight;
+  if (tk.subtk2height.skewer == 0) {
+    maxh *= 2;
+  }
+  const v = maxh / rows.length;
+  if (v > maxRowHeight) return [maxRowHeight, 1];
+  if (v > 3) return [Math.floor(v), 1];
+  if (v > 1) return [Math.floor(v), 0];
+  return [v, 0];
+}
+function may_render_cnv(data, tk, block) {
+  if (!tk.cnv) return;
+  tk.cnv?.g.selectAll("*").remove();
+  delete tk.cnv.cnvLst;
+  delete tk.cnv.cnvInDensity;
+  delete tk.cnv.cnvMsg;
+  if (data.cnv) {
+    if (!Array.isArray(data.cnv.cnvs)) throw "data.cnv.cnvs[] not array";
+    tk.cnv.cnvMsg = data.cnv.cnvMsg;
+    renderSegments(data, tk, block);
+    return;
+  }
+  if (data.cnvDensity) {
+    tk.cnv.cnvInDensity = true;
+    tk.cnv.cnvMsg = data.cnvDensity.cnvMsg;
+    renderDensity(data, tk, block);
+    return;
+  }
+  tk.subtk2height.cnv = 0;
+  if (tk.cnv) tk.cnv.cnvLst = [];
+}
+function renderDensity(data, tk, block) {
+  tk.cnv.g.append("image").attr("width", block.width).attr("height", tk.cnv.density.barheight).attr("xlink:href", data.cnvDensity.gain.src);
+  tk.cnv.g.append("image").attr("width", block.width).attr("height", tk.cnv.density.barheight).attr("xlink:href", data.cnvDensity.loss.src).attr("y", tk.cnv.density.barheight);
+  axisstyle({
+    axis: tk.cnv.g.append("g").attr("transform", `translate(-1,0)`).call(
+      axisRight().scale(linear().domain([0, data.cnvDensity.max]).range([tk.cnv.density.barheight, 0])).tickValues([0, data.cnvDensity.max])
+    ),
+    color: "black",
+    showline: true
+  });
+  axisstyle({
+    axis: tk.cnv.g.append("g").attr("transform", `translate(-1,${tk.cnv.density.barheight})`).call(
+      axisRight().scale(linear().domain([0, data.cnvDensity.max]).range([0, tk.cnv.density.barheight])).tickValues([0, data.cnvDensity.max])
+    ),
+    color: "black",
+    showline: true
+  });
+  tk.cnv.g.append("text").text("Gain").attr("font-size", block.labelfontsize * 0.9).attr("x", 5).attr("y", tk.cnv.density.barheight / 2);
+  tk.cnv.g.append("text").text("Loss").attr("font-size", block.labelfontsize * 0.9).attr("x", 5).attr("y", tk.cnv.density.barheight * 1.5);
+  tk.subtk2height.cnv = tk.cnv.density.barheight * 2;
+}
+function renderSegments(data, tk, block) {
+  const [cnvBySample, cnvLst, absoluteMax] = prepData(data, tk, block);
+  tk.cnv.cnvLst = cnvLst;
+  tk.cnv.absoluteMax = absoluteMax;
+  tk.cnv.colorScale = linear(
+    tk.cnv.presetMax ? [-tk.cnv.presetMax, 0, tk.cnv.presetMax] : [-absoluteMax, 0, absoluteMax],
+    [tk.cnv.lossColor, "white", tk.cnv.gainColor]
+  ).clamp(true);
+  const [rowheight, rowspace] = getRowHeight(cnvBySample || cnvLst, tk);
+  if (cnvBySample) {
+    for (const sample of cnvBySample) {
+      for (const c of sample.cnvs) {
+        plotOneSegment(c, sample.y * (rowheight + rowspace), rowheight, tk, block, sample);
+      }
+    }
+  } else {
+    for (const c of cnvLst) {
+      plotOneSegment(c, c.y * (rowheight + rowspace), rowheight, tk, block);
+    }
+  }
+  const rowc = (cnvBySample || cnvLst).length;
+  tk.subtk2height.cnv = rowc * rowheight + (rowc - 1) * rowspace;
+}
+function prepData(data, tk, block) {
+  let maxAbsoluteValue = 0;
+  const sample2cnv = /* @__PURE__ */ new Map();
+  const cnvLst = [];
+  for (const v of data.cnv.cnvs) {
+    if (!v.chr) continue;
+    if (!Number.isInteger(v.start) || !Number.isInteger(v.stop)) continue;
+    const t1 = block.seekcoord(v.chr, v.start)[0];
+    if (!t1) continue;
+    const t2 = block.seekcoord(v.chr, v.stop)[0];
+    if (!t2) continue;
+    const j = structuredClone(v);
+    if (t1.x > t2.x) {
+      j.x1 = t2.x;
+      j.x2 = t1.x;
+    } else {
+      j.x1 = t1.x;
+      j.x2 = t2.x;
+    }
+    if (Number.isFinite(v.value)) maxAbsoluteValue = Math.max(maxAbsoluteValue, Math.abs(v.value));
+    cnvLst.push(j);
+    if (Array.isArray(v.samples)) {
+      for (const s of v.samples) {
+        if (!sample2cnv.has(s.sample_id)) sample2cnv.set(s.sample_id, []);
+        sample2cnv.get(s.sample_id).push(structuredClone(j));
+      }
+    }
+  }
+  let samples;
+  if (sample2cnv.size) {
+    samples = [];
+    for (const [s, cnvs] of sample2cnv) {
+      cnvs.sort((a, b) => a.x1 - b.x1);
+      samples.push({
+        sample_id: s,
+        cnvs,
+        x1: Math.min(...cnvs.map((i) => i.x1)),
+        x2: Math.max(...cnvs.map((i) => i.x2))
+      });
+    }
+    samples.sort((a, b) => a.x1 - b.x1);
+    for (let i = 0; i < samples.length; i++) samples[i].y = i;
+  } else {
+    cnvLst.sort((a, b) => a.x1 - b.x1);
+    stackRows(cnvLst, 0);
+  }
+  return [samples, cnvLst, Math.min(tk.cnv.absoluteValueRenderMax, maxAbsoluteValue)];
+}
+function plotOneSegment(c, y, rowheight, tk, block, sample) {
+  const x1 = Math.max(0, c.x1), x2 = Math.min(c.x2, block.width);
+  tk.cnv.g.append("rect").attr("x", x1).attr("y", y).attr("width", x2 - x1).attr("height", Math.max(rowheight, 1)).attr("fill", Number.isFinite(c.value) ? tk.cnv.colorScale(c.value) : mclass[c.class].color).on("mouseover", (event2) => {
+    event2.target.setAttribute("stroke", "black");
+    tk.hovertip.clear().show(event2.clientX, event2.clientY);
+    const table = table2col({ holder: tk.hovertip.d });
+    table_cnv({ mlst: [c], tk }, table);
+    if (sample) {
+      const [t1, t2] = table.addRow();
+      t1.text("Sample");
+      t2.text(sample.sample_id);
+    }
+  }).on("mouseout", (event2) => {
+    event2.target.setAttribute("stroke", "");
+    tk.hovertip.hide();
+  }).on("click", async (event2) => {
+    tk.itemtip.clear().show(event2.clientX, event2.clientY);
+    await itemtable_oneItem({
+      mlst: [c],
+      tk,
+      block,
+      div: tk.itemtip.d
+    });
+    return;
+    const table = table2col({ holder: tk.itemtip.d });
+    const cnv = structuredClone(c);
+    if (sample) {
+      cnv.samples = [{ sample_id: sample.sample_id }];
+    }
+    table_cnv({ mlst: [cnv], tk }, table, true);
+  });
+}
+function stackRows(lst, spacing) {
+  const stacks = [];
+  for (const item of lst) {
+    for (let i = 0; i < stacks.length; i++) {
+      if (stacks[i] + spacing < item.x1) {
+        stacks[i] = item.x2;
+        item.y = i;
+        break;
+      }
+    }
+    if (!("y" in item)) {
+      item.y = stacks.length;
+      stacks.push(item.x2);
+    }
+  }
+}
+
+// mds3/tk.js
+async function loadTk(tk, block) {
+  block.tkcloakon(tk);
+  block.block_setheight();
+  try {
+    if (!tk.mds || tk.uninitialized) {
+      await makeTk(tk, block);
+    }
+    const data = await getTkData(tk, block);
+    if (tk.uninitialized) {
+      tk.clear();
+      delete tk.uninitialized;
+    }
+    may_render_skewer(data, tk, block);
+    may_render_cnv(data, tk, block);
+    await make_leftlabels(data, tk, block);
+    tk._finish(data);
+  } catch (e) {
+    if (tk.clear) tk.clear();
+    if (tk.subtk2height) tk.subtk2height.skewer = 50;
+    if (tk._finish) tk._finish({ error: e.message || e });
+    if (e.stack) console.log(e.stack);
+    return;
+  }
+}
+function getParameter(tk, block) {
+  const par = {
+    genome: block.genome.name,
+    // instructs server to return data types associated with tracks
+    // including skewer or non-skewer
+    forTrack: 1,
+    // may not pass skewerRim if it is not in use (turn off)
+    skewerRim: tk.mds.queries?.snvindel?.skewerRim,
+    // instructions for counting rim counts per variant
+    hardcodeCnvOnly: tk.hardcodeCnvOnly
+  };
+  const headers = { "Content-Type": "application/json", Accept: "application/json" };
+  par.skewer = 1;
+  if (tk.set_id) {
+    par.set_id = tk.set_id;
+  }
+  if (tk.filter0) {
+    par.filter0 = tk.filter0;
+  }
+  if (tk.filterObj) {
+    if (tk.filterObj?.lst.length) {
+      par.filterObj = tk.filterObj;
+    }
+  }
+  if (tk.token) {
+    headers["X-Auth-Token"] = tk.token;
+  }
+  if (tk.mds.label) {
+    par.dslabel = tk.mds.label;
+  } else {
+    if (tk.bcf) {
+      if (tk.bcf.file) {
+        par.bcffile = tk.bcf.file;
+      } else if (tk.bcf.url) {
+        par.bcfurl = tk.bcf.url;
+        if (tk.bcf.indexURL) par.bcfindexURL = tk.bcf.indexURL;
+      } else {
+        throw ".file and .url missing for tk.bcf{}";
+      }
+    }
+  }
+  rangequery_rglst(tk, block, par);
+  if (tk.legend?.mclass.hiddenvalues.size) {
+    par.hiddenmclasslst = JSON.stringify([...tk.legend.mclass.hiddenvalues]);
+  }
+  if (tk.legend?.bcfInfo) {
+    const infoFilter = {};
+    for (const k in tk.legend.bcfInfo) {
+      if (tk.legend.bcfInfo[k].hiddenvalues.size) {
+        infoFilter[k] = [...tk.legend.bcfInfo[k].hiddenvalues];
+      }
+    }
+    if (Object.keys(infoFilter).length) {
+      par.infoFilter = infoFilter;
+    }
+  }
+  if (tk.legend?.formatFilter) {
+    const filter = {};
+    for (const k in tk.legend.formatFilter) {
+      if (tk.legend.formatFilter[k].hiddenvalues.size) {
+        filter[k] = [...tk.legend.formatFilter[k].hiddenvalues];
+      }
+    }
+    if (Object.keys(filter).length) {
+      par.formatFilter = filter;
+    }
+  }
+  if (tk.cnv) {
+    if (tk.cnv.cnvMaxLength) par.cnvMaxLength = tk.cnv.cnvMaxLength;
+    if (tk.cnv.cnvGainCutoff) par.cnvGainCutoff = tk.cnv.cnvGainCutoff;
+    if (tk.cnv.cnvLossCutoff) par.cnvLossCutoff = tk.cnv.cnvLossCutoff;
+    par.cnvDensity = {
+      width: block.width,
+      barheight: tk.cnv.density.barheight,
+      pcolor: tk.cnv.gainColor,
+      ncolor: tk.cnv.lossColor
+    };
+  }
+  return [par, headers];
+}
+async function getTkData(tk, block) {
+  let data;
+  if (tk.custom_variants) {
+    data = await dataFromCustomVariants(tk, block);
+  } else {
+    const [body, headers] = getParameter(tk, block);
+    data = await dofetch3("mds3", { body, headers });
+  }
+  if (data.error) throw data.error;
+  return data;
+}
+function rangequery_rglst(tk, block, par) {
+  if (typeof par != "object") throw "par{} is not object";
+  let rglst = [];
+  if (block.usegm) {
+    const r = {
+      chr: block.rglst[0].chr,
+      reverse: block.rglst[0].reverse,
+      width: 0,
+      start: null,
+      stop: null
+    };
+    for (let i = block.startidx; i <= block.stopidx; i++) {
+      const j = block.rglst[i];
+      r.width += j.width + block.regionspace;
+      r.start = r.start == null ? j.start : Math.min(r.start, j.start);
+      r.stop = r.stop == null ? j.stop : Math.max(r.stop, j.stop);
+    }
+    rglst.push(r);
+    if (block.gmmode == "genomic") {
+    } else {
+      par.isoform = block.usegm.isoform;
+      par.gene = block.usegm.name;
+    }
+  } else {
+    rglst = block.tkarg_rglst(tk);
+  }
+  let xoff = 0;
+  for (const r of rglst) {
+    r.xoff = 0;
+    xoff += r.width + block.regionspace;
+  }
+  if (block.subpanels.length == tk.subpanels.length) {
+    for (const r of block.subpanels) {
+      rglst.push({
+        chr: r.chr,
+        start: r.start,
+        stop: r.stop,
+        width: r.width,
+        exonsf: r.exonsf,
+        xoff
+      });
+      xoff += r.width + r.leftpad;
+    }
+  }
+  par.rglst = rglst;
+  par.regionspace = block.regionspace;
+  par.devicePixelRatio = window.devicePixelRatio > 1 ? window.devicePixelRatio : 1;
+}
+async function dataFromCustomVariants(tk, block) {
+  const data = {
+    // these holder will contain subset of tk.custom_variants[] that are in view range
+    skewer: [],
+    // for non-cnv data
+    cnv: {
+      cnvs: []
+      // for cnv segments
+    }
+    // adds mclass2variantcount[] later
+  };
+  let bbstart = null, bbstop;
+  for (let i = block.startidx; i <= block.stopidx; i++) {
+    if (bbstart == null) {
+      bbstart = block.rglst[i].start;
+      bbstop = block.rglst[i].stop;
+    } else {
+      bbstart = Math.min(bbstart, block.rglst[i].start);
+      bbstop = Math.max(bbstop, block.rglst[i].stop);
+    }
+  }
+  for (const m of tk.custom_variants) {
+    if (tk.legend?.bcfInfo) {
+      let skip = false;
+      for (const infoKey in tk.legend.bcfInfo) {
+        if (tk.legend.bcfInfo[infoKey].hiddenvalues?.size) {
+          const v = m.info?.[infoKey] || unannotatedKey;
+          if (tk.legend?.bcfInfo[infoKey].hiddenvalues.has(v)) {
+            skip = true;
+            break;
+          }
+        }
+      }
+      if (skip) continue;
+    }
+    if (m.dt == dtcnv) {
+      if (m.chr != block.rglst[0].chr) continue;
+      if (Math.max(m.start, bbstart) > Math.min(m.stop, bbstop)) continue;
+      data.cnv.cnvs.push(m);
+    } else if (m.dt == dtsnvindel || m.dt == dtsv || m.dt == dtfusionrna) {
+      if (m.chr != block.rglst[0].chr) continue;
+      if (m.pos <= bbstart || m.pos >= bbstop) continue;
+      if (!m.class) m.class = "X";
+      if (!mclass[m.class]) m.class = "X";
+      if (tk.legend?.mclass.hiddenvalues.has(m.class)) continue;
+      data.skewer.push(m);
+    } else {
+      throw "unknown custom data dt";
+    }
+  }
+  data.mclass2variantcount = summarize_mclass([...data.skewer, ...data.cnv.cnvs]);
+  if (data.cnv.cnvs.length == 0) delete data.cnv;
+  const set = /* @__PURE__ */ new Set();
+  if (data.skewer?.some((i) => i.samples)) {
+    for (const m of data.skewer) {
+      if (m.samples) {
+        for (const s of m.samples) set.add(s.sample_id);
+      }
+    }
+  }
+  if (data.cnv?.cnvs?.some((i) => i.samples)) {
+    for (const m of data.cnv.cnvs) {
+      if (m.samples) {
+        for (const s of m.samples) set.add(s.sample_id);
+      }
+    }
+  }
+  if (set.size) data.sampleTotalNumber = set.size;
+  await mayDoLDoverlay(tk, data.skewer);
+  return data;
+}
+async function mayDoLDoverlay(tk) {
+  if (!tk.mds.queries?.ld?.mOverlay) return;
+  if (!tk.mds.termdb?.vocabApi) return;
+  delete tk.mds.queries.ld.mOverlay.data;
+  const data = await tk.mds.termdb.vocabApi.getLDdata(tk.mds.queries.ld.mOverlay.ldtkname, tk.mds.queries.ld.mOverlay.m);
+  if (data.error || !Array.isArray(data.lst)) return;
+  tk.mds.queries.ld.mOverlay.data = data.lst;
+}
+
+export {
+  displaySampleTable,
+  getFilterName,
+  makelabel,
+  loadTk,
+  rangequery_rglst
+};
+//# sourceMappingURL=chunk-NF34NHZM.js.map