@sjcrh/proteinpaint-client 2.226.0 → 2.227.0

package/dist/chunk-VPRP24DY.js

@@ -0,0 +1,2095 @@
+import {
+  recoverInit
+} from "./chunk-4E2F26CC.js";
+import {
+  getSavedStateRefusal,
+  markSavedState,
+  parentCorsMessage
+} from "./chunk-O6T4SDC7.js";
+import {
+  chartsInit,
+  escapeHtml,
+  fillTermWrapper,
+  filterRxCompInit,
+  first_genetrack_tolist,
+  getFilterItemByTag,
+  getSampleFilter,
+  getTermSampleTypes,
+  groupsInit,
+  keyupEnter,
+  makeDNAMethRegionTerm,
+  mayRenderSampleTypeRow,
+  renderTable,
+  sayerror,
+  table2col,
+  to_textfile
+} from "./chunk-YBXQBSFY.js";
+import {
+  importPlot
+} from "./chunk-QKVKQD6S.js";
+import {
+  Menu
+} from "./chunk-CNFTQSNE.js";
+import {
+  icons
+} from "./chunk-3CIL7KH7.js";
+import {
+  dofetch3
+} from "./chunk-VVWZ4BOI.js";
+import {
+  trimGvTermsForSave
+} from "./chunk-CFYWQJ7F.js";
+import {
+  dtcnv,
+  dtfusionrna,
+  dtsnvindel,
+  dtsv
+} from "./chunk-2N345NXD.js";
+import {
+  getCompInit,
+  multiInit
+} from "./chunk-HBNB5TRH.js";
+import {
+  select_default
+} from "./chunk-I6Y4O3RR.js";
+
+// mass/about.ts
+var cohortTableActiveColor = "yellow";
+var MassAbout = class _MassAbout {
+  constructor(opts) {
+    this.initCohort = (appState) => {
+      if (this.selectCohort == null) return;
+      if (!this.selectCohort.values) return;
+      const instanceNum2 = this.instanceNum;
+      const activeCohort = appState.activeCohort;
+      const app = this.app;
+      this.dom.cohortOpts.append("table").attr("data-testid", "sjpp-about-cohort-options-table").selectAll("tr").data(this.selectCohort.values).enter().append("tr").each(function(d, i, nodes) {
+        const tr = select_default(nodes[i]);
+        const td0 = tr.append("td");
+        const radioName = "sja-termdb-cohort-" + instanceNum2;
+        const radioId = radioName + "-" + i;
+        td0.append("input").style("scale", "1.2").attr("type", "radio").attr("name", radioName).attr("id", radioId).attr("value", i).property("checked", i === activeCohort).style("margin-right", "5px").style("margin-left", "0px").on("click", async (event) => {
+          const state = app.getState();
+          const clearOnChange = state.termdbConfig.selectCohort.clearOnChange;
+          if (clearOnChange) {
+            const subactions = [];
+            const toBeCleared = [];
+            const plots = state.plots;
+            const filter = state.termfilter.filter.lst.find((f) => f.tag == "filterUiRoot")?.lst;
+            const groups = state.groups;
+            if (clearOnChange.plots && plots?.length) toBeCleared.push("plots");
+            for (const plot of plots) {
+              subactions.push({
+                type: "plot_delete",
+                id: plot.id
+              });
+            }
+            if (clearOnChange.filter && filter?.length) toBeCleared.push("filters");
+            subactions.push({
+              type: "filter_replace",
+              filter: {
+                type: "tvslst",
+                in: true,
+                join: "",
+                tag: "filterUiRoot",
+                lst: []
+              }
+            });
+            if (clearOnChange.groups && groups?.length) {
+              toBeCleared.push("groups");
+              for (const group of groups) {
+                subactions.push({
+                  type: "delete_group",
+                  name: group.name
+                });
+              }
+              for (const term of state.customTerms) {
+                subactions.push({
+                  type: "delete_customTerm",
+                  name: term.name
+                });
+              }
+            }
+            subactions.push({ type: "cohort_set", activeCohort: i });
+            if (toBeCleared.length) {
+              const confirm = window.confirm(
+                `Changing the cohort will clear all ${joinByComma(
+                  toBeCleared
+                )}. To proceed, click "OK". To save the session, click "Cancel" and then click the "Session" button at the top of the page.`
+              );
+              if (!confirm) {
+                event.preventDefault();
+                return;
+              }
+            }
+            app.dispatch({
+              type: "app_refresh",
+              subactions
+            });
+          } else app.dispatch({ type: "cohort_set", activeCohort: i });
+        });
+        td0.append("label").style("font-size", "1.4em").attr("for", radioId).attr("colspan", 2).style("cursor", "pointer").html((d2) => d2.label);
+        tr.selectAll("td").style("max-width", "600px").style("padding-bottom", "10px").style("padding-right", "20px").style("vertical-align", "top");
+      });
+      this.dom.cohortTable = this.subheader.append("div").attr("data-testid", "sjpp-about-cohort-table").style("margin-left", "12px");
+      if (this.selectCohort.asterisk) {
+        this.dom.cohortAsterisk = this.subheader.append("div").attr("data-testid", "sjpp-about-cohort-asterisk").style("margin", "10px").style("font-size", ".8em").text(this.selectCohort.asterisk);
+      }
+    };
+    this.renderCohortsTable = async () => {
+      if (!this.dom.cohortTable) return;
+      this.dom.cohortTable.selectAll("*").remove();
+      const columns = [{ label: "Feature" }];
+      const rows = [];
+      const result = await this.app.vocabApi.getCohortsData();
+      if ("error" in result) throw result.error;
+      if (this.selectCohort?.values) {
+        const values = this.selectCohort.values;
+        result.cohorts.sort((a, b) => {
+          const aIndex = values.findIndex((v) => v.keys.toString() == a.cohort);
+          const bIndex = values.findIndex((v) => v.keys.toString() == b.cohort);
+          if (aIndex < bIndex) return -1;
+          if (aIndex > bIndex) return 1;
+          return 0;
+        });
+      }
+      if (!result.cfeatures.length) return;
+      for (const feature of result.features) rows.push([{ value: feature.name }]);
+      for (const cohort of result.cohorts) {
+        if (cohort.subcohorts?.length) continue;
+        columns.push({ label: cohort.name });
+        for (const [i, feature] of result.features.entries()) {
+          const cf = result.cfeatures.find((cf2) => cf2.idfeature === feature.idfeature && cf2.cohort === cohort.cohort);
+          if (cf) rows[i].push({ value: cf.value });
+        }
+      }
+      renderTable({
+        rows,
+        columns,
+        div: this.dom.cohortTable,
+        showLines: false,
+        maxHeight: "60vh",
+        header: { style: { "font-size": "1.2em", "font-weight": "bold" } }
+      });
+      this.dom.cohortTable.select("table").style("border-collapse", "collapse");
+      this.dom.cohortTable.selectAll(`tbody > tr > td`).style("background-color", "transparent").style("padding", "6px");
+      const state = this.app.getState();
+      const selectCohort = state.termdbConfig.selectCohort;
+      const activeCohort = state.activeCohort;
+      const keys = selectCohort.values[activeCohort].keys;
+      let selector = `tbody > tr > td:nth-child(${activeCohort + 2})`;
+      const combined = keys.length > 1;
+      if (combined) {
+        selector = "";
+        for (const key of keys) {
+          const i = result.cohorts.map((c) => c.cohort).indexOf(key);
+          if (selector !== "") selector += ",";
+          selector += `tbody > tr > td:nth-child(${i + 2})`;
+        }
+      }
+      const activeColumns = this.dom.cohortTable.selectAll(selector);
+      const color = state.termdbConfig.massNav?.activeColor || cohortTableActiveColor;
+      activeColumns.style("background-color", color);
+    };
+    this.initCustomHtml = () => {
+      if (this.selectCohort != null) return;
+      if (!this.aboutOverrides?.html) return;
+      this.subheader.append("div").attr("data-testid", "sjpp-custom-about-content").style("padding", "10px").html(this.aboutOverrides.html);
+    };
+    // render the world map (from termdbConfig.geomap) directly on the landing tab when the dataset opts in.
+    // the renderer (and its ~170KB world.json basemap) is dynamically imported so it never loads for
+    // datasets that don't enable the map.
+    this.initGeomap = async (appState) => {
+      if (!this.aboutOverrides?.showGeomap) return;
+      const geomap = appState.termdbConfig?.geomap;
+      if (!geomap?.sites?.length) return;
+      const holder = this.subheader.append("div").attr("data-testid", "sjpp-about-geomap").style("padding", "10px");
+      const { renderGeomap } = await import("./render-S47OJIIP.js");
+      renderGeomap(holder, geomap);
+    };
+    // render the sunburst of the dataset's default rings when the dataset opts in. like the geomap,
+    // its module is dynamically imported so it only loads for datasets that show it; main() draws it
+    this.initSunburst = (appState) => {
+      if (!this.aboutOverrides?.showSunburst) return;
+      if (!appState.termdbConfig?.sunburst?.twLst?.length) return;
+      const s = this.aboutOverrides.showSunburst;
+      const placed = typeof s == "object" ? this.getSectionHolder(s.holderSelector, "showSunburst") : void 0;
+      const section = (placed || this.subheader.append("div")).style("padding", "10px");
+      if (typeof s == "object") this.sectionHeading(section, s.title, s.description);
+      const holder = section.append("div").style("display", "flex").style("justify-content", "center").style("margin-bottom", "32px");
+      const onOpen = () => this.launchActiveItem({ plot: { chartType: "sunburst" } }, holder.node());
+      this.sunburst = import("./aboutSunburst-53YAWTV5.js").then((_) => new _.AboutSunburst(holder, this.app, onOpen)).catch((e) => {
+        holder.append("div").attr("class", "sja_errorbar").text(e?.message || String(e));
+        console.error(e);
+      });
+    };
+    // the element of the custom html that a section's holderSelector (a css selector from the dataset)
+    // selects; undefined without one, or when it selects nothing, and then the section follows the content above
+    this.getSectionHolder = (selector, section) => {
+      if (!selector) return;
+      let el;
+      try {
+        el = this.subheader.select(selector);
+      } catch (_) {
+      }
+      if (el && !el.empty()) return el;
+      console.error(`about tab: ${section}.holderSelector '${selector}' selects no element of the html; shown at the end`);
+    };
+    // a section's centered heading and text, from the dataset; nothing if neither is given
+    this.sectionHeading = (holder, title, description) => {
+      if (!title && !description) return;
+      const div = holder.append("div").style("text-align", "center").style("margin", "24px 0 12px 0");
+      if (title)
+        div.append("div").attr("data-testid", "sjpp-about-section-title").style("font-size", "1.4em").style("font-weight", "600").style("color", "#243b53").html(title);
+      if (description)
+        div.append("div").style("margin-top", "6px").style("font-size", ".95em").style("color", "#4b5563").html(description);
+    };
+    this.initActiveItems = () => {
+      if (!this.aboutOverrides?.activeItems) return;
+      const placed = this.getSectionHolder(this.aboutOverrides.activeItems.holderSelector, "activeItems");
+      const holder = placed || this.subheader;
+      const { title, description } = this.aboutOverrides.activeItems;
+      this.sectionHeading(holder, title, description);
+      if (this.aboutOverrides.activeItems.layout == "cards") {
+        this.initActiveItemCards(holder);
+        return;
+      }
+      const div = holder.append("div").attr("data-testid", "sjpp-custom-about-activeItems").style("padding", placed ? "0px 0px 10px 0px" : "0px 0px 10px 20px");
+      for (const item of this.aboutOverrides.activeItems.items) {
+        const btn = div.append("div").style("display", "inline-block").style("margin", "5px").attr("class", "sja_menuoption").attr("data-testid", "sjpp-custom-active-item-btn").html(item.title);
+        this.makeActivatable(btn, () => this.launchActiveItem(item, btn.node()));
+      }
+    };
+    // render activeItems as large square tiles (homepage style) that lift on hover
+    this.initActiveItemCards = (parent) => {
+      const items = this.aboutOverrides.activeItems.items;
+      const holder = parent.append("div").attr("data-testid", "sjpp-custom-about-activeItems").style("display", "flex").style("flex-wrap", "wrap").style("justify-content", "center").style("gap", "24px").style("padding", "20px 20px 30px 20px");
+      for (const item of items) {
+        const card = holder.append("div").attr("class", "sjpp-about-card").attr("data-testid", "sjpp-custom-active-item-card");
+        if (item.icon) card.append("div").attr("class", "sjpp-about-card-icon").html(item.icon);
+        card.append("div").attr("class", "sjpp-about-card-title").html(item.title);
+        card.append("div").attr("class", "sjpp-about-card-subtitle").text(item.subtitle || "");
+        this.makeActivatable(card, () => this.launchActiveItem(item, card.node()));
+      }
+    };
+    // make a non-native clickable element (a styled <div>) operable like a button:
+    this.makeActivatable = (sel, onActivate) => {
+      sel.attr("role", "button").attr("tabindex", 0).on("click", () => onActivate()).on("keydown", (event) => {
+        if (event.key == "Enter" || event.key == " ") {
+          event.preventDefault();
+          onActivate();
+        }
+      });
+    };
+    // launch behavior shared by button and card layouts
+    this.launchActiveItem = async (item, anchorEl) => {
+      if (item.menu) {
+        this.openItemMenu(item.menu, anchorEl);
+        return;
+      }
+      if (item.openChartMenu) {
+        await this.openChartMenu(item.openChartMenu, anchorEl);
+        return;
+      }
+      if (!item.plot) {
+        console.error("about activeItem has neither .plot nor .openChartMenu", item);
+        return;
+      }
+      await this.app.dispatch({
+        type: "tab_set",
+        activeTab: 1
+      });
+      this.app.dispatch({
+        type: "plot_create",
+        id: getId(),
+        config: structuredClone(item.plot)
+      });
+    };
+    // menu of launch items in labelled groups, anchored to the tile. An entry with its own
+    // chart menu (e.g. a gene search) replaces this menu's content in place; other entries
+    // hide the menu and launch their plot.
+    this.openItemMenu = (groups, anchorEl) => {
+      const menu = this.chartMenu || (this.chartMenu = new Menu({ padding: "0px" }));
+      menu.clear();
+      const holder = menu.d.append("div").style("padding", "6px 0").style("min-width", "260px");
+      for (const group of groups) {
+        if (group.label) {
+          holder.append("div").style("padding", "6px 14px 2px").style("font-size", "0.75em").style("font-weight", "bold").style("letter-spacing", "0.05em").style("text-transform", "uppercase").style("color", "#777").text(group.label);
+        }
+        for (const entry of group.items || []) {
+          const row = holder.append("div").attr("class", "sja_menuoption").style("padding", "6px 14px");
+          row.append("div").style("font-weight", "600").html(entry.title);
+          if (entry.subtitle) row.append("div").style("font-size", "0.8em").style("color", "#666").text(entry.subtitle);
+          this.makeActivatable(row, async () => {
+            if (!entry.openChartMenu && !entry.menu) menu.hide();
+            await this.launchActiveItem(entry, anchorEl);
+          });
+        }
+      }
+      menu.showunder(anchorEl);
+    };
+    // open a chart-specific launch menu (e.g. gene search for proteinView) anchored to the tile.
+    // the chart module is dynamically imported so its code only loads when the tile is clicked.
+    this.openChartMenu = async (chartType, anchorEl) => {
+      const menu = this.chartMenu || (this.chartMenu = new Menu({ padding: "0px" }));
+      menu.clear();
+      const shimApp = {
+        opts: this.app.opts,
+        dispatch: async (action) => {
+          if (action.type == "plot_create") await this.app.dispatch({ type: "tab_set", activeTab: 1 });
+          return this.app.dispatch(action);
+        }
+      };
+      const chartsInstanceShim = { app: shimApp, dom: { tip: menu } };
+      const _ = await importPlot(chartType);
+      if (typeof _.makeChartBtnMenu != "function")
+        throw `about activeItem openChartMenu: chart '${chartType}' has no makeChartBtnMenu`;
+      _.makeChartBtnMenu(menu.d.append("div"), chartsInstanceShim, chartType);
+      menu.showunder(anchorEl);
+    };
+    this.initDisclaimer = () => {
+      const d = this.aboutOverrides?.disclaimer;
+      if (!d) return;
+      const div = this.subheader.append("div").attr("data-testid", "sjpp-custom-about-disclaimer").style("margin", "10px 0 20px 10px").style("opacity", 0.7).style("padding", "10px").style("background-color", "#f8f9fa").style("border-left", "4px solid #6c757d").style("font-size", "0.8em");
+      div.append("div").style("margin-bottom", "8px").style("font-weight", "bold").text("DISCLAIMER");
+      div.append("div").text(d.text);
+    };
+    this.showServerInfo = () => {
+      const state = this.app.getState();
+      const about = state.termdbConfig.massNav?.tabs?.about;
+      if (!about && !this.app.opts.pkgver && !this.app.opts.launchDate) return;
+      const dataRelease = about?.dataRelease;
+      const additionalInfo = about?.additionalInfo;
+      const div = this.subheader.append("div").attr("data-testid", "sjpp-about-server-info").style("margin", "10px").style("font-size", ".8em");
+      const htmlArr = [];
+      if (dataRelease) {
+        htmlArr.push(`Data Release: <a href=${dataRelease.link} target=_blank>${dataRelease.version}</a>`);
+      }
+      if (this.app.opts.pkgver) {
+        htmlArr.push(
+          `Software Release: <a href=https://github.com/stjude/proteinpaint/pkgs/container/ppfull target=_blank>${this.app.opts.pkgver}</a>`
+        );
+      }
+      if (this.app.opts.launchDate) {
+        htmlArr.push(`Server Launched: ${this.app.opts.launchDate}`);
+      }
+      if (additionalInfo) {
+        htmlArr.push(additionalInfo);
+      }
+      div.append("div").html(htmlArr.join("; "));
+    };
+    this.opts = opts;
+    this.type = _MassAbout.type;
+    this.app = opts.app;
+    this.subheader = opts.subheader;
+    this.instanceNum = opts.instanceNum;
+    this.aboutOverrides = opts.aboutOverrides;
+    this.selectCohort = opts.selectCohort;
+    this.dom = {
+      cohortDescription: this.subheader.append("div").attr("data-testid", "sjpp-about-cohort-desc").style("margin-left", "10px")
+    };
+    if (opts?.selectCohort?.title) {
+      this.dom.cohortTitle = opts.subheader.append("h2").attr("data-testid", "sjpp-about-cohort-title").style("margin-left", "10px").text(opts.selectCohort.title);
+    }
+    if (opts.selectCohort?.prompt) {
+      this.dom.cohortPrompt = this.subheader.append("div").attr("data-testid", "sjpp-about-cohort-prompt").style("margin-left", "10px").style("padding-top", "30px").style("padding-bottom", "10px").style("font-weight", "bold").style("font-size", "1.2em").text(opts.selectCohort.prompt);
+    }
+    if (opts.selectCohort) {
+      this.dom.cohortOpts = this.subheader.append("div").style("margin-bottom", "30px").style("margin-left", "10px");
+    }
+  }
+  static {
+    this.type = "about";
+  }
+  /* render all contents into this.subheader
+  do it through init() means that contents are rendered just once on launching mass ui and won't be rerendered or updated
+  since there's no reason to update about tab contents while user is interacting with mass ui
+  */
+  init(appState) {
+    this.initCohort(appState);
+    this.initCustomHtml();
+    this.initGeomap(appState);
+    this.initSunburst(appState);
+    this.initActiveItems();
+    this.initDisclaimer();
+    this.showServerInfo();
+  }
+  async main() {
+    if (this.state.nav.activeTab !== 0) return;
+    await this.renderCohortsTable();
+    if (this.sunburst) await (await this.sunburst)?.update(this.state);
+    if (this.opts.selectCohort) {
+      if (this.opts.selectCohort.description) {
+        this.dom.cohortDescription.html(this.opts.selectCohort.description);
+      } else if (this.opts.selectCohort.descriptionByCohort) {
+        this.dom.cohortDescription.html(
+          this.opts.selectCohort.descriptionByCohort[this.state.termdbConfig.selectCohort.values[this.state.activeCohort].keys.join(",")]
+        );
+      }
+    }
+  }
+  destroy() {
+    void this.sunburst?.then((sunburst) => sunburst?.chart.destroy());
+  }
+};
+var aboutInit = getCompInit(MassAbout);
+function joinByComma(arr) {
+  if (!arr.length) return "";
+  else if (arr.length == 1) return arr[0];
+  else if (arr.length == 2) return arr.join(" and ");
+  else return `${arr.slice(0, -1).join(", ")}, and ${arr.slice(-1)}`;
+}
+
+// mass/search.ts
+var MIN_PROMPT_LENGTH_FOR_GENE_SEARCH = 1;
+var MIN_PROMPT_LENGTH_FOR_OTHER_SEARCH = 3;
+var MAX_PROMPT_LENGTH_FOR_OMNISEARCH = 20;
+async function embedMethylationRegionPicker(opts) {
+  const { holder, genomeObj, vocabApi, chr, start, stop, callback } = opts;
+  if (!chr || !Number.isInteger(start) || !Number.isInteger(stop)) throw new Error("unable to retrieve gene coordinate");
+  holder.selectAll("*").remove();
+  holder.style("display", "block");
+  const query = vocabApi.termdbConfig?.queries.dnaMethylation;
+  const sampleTypeSelect = mayRenderSampleTypeRow(holder.append("div"), query, vocabApi.termdbConfig);
+  holder.append("div").style("opacity", 0.6).text("Navigate genome browser to desired region");
+  const arg = {
+    holder,
+    genome: genomeObj,
+    // genome obj
+    chr,
+    start,
+    stop,
+    tklst: [],
+    nobox: true,
+    width: 500,
+    hidegenelegend: true,
+    debugmode: opts.debug
+  };
+  first_genetrack_tolist(genomeObj, arg.tklst);
+  const _ = await import("./block-AGX6Z4BR.js");
+  const blockInstance = new _.Block(arg);
+  holder.append("div").attr("data-testid", "sjpp-dnaMethylation-submitDiv").style("margin", "10px 0px").append("button").style("border", "none").style("border-radius", "20px").style("padding", "10px 15px").text("Submit Region").on("click", async () => {
+    const termSampleTypes = getTermSampleTypes(sampleTypeSelect, query, vocabApi.termdbConfig);
+    if (!termSampleTypes) return;
+    const { chr: chr2, start: start2, stop: stop2 } = blockInstance.rglst[0];
+    await callback(makeDNAMethRegionTerm({ chr: chr2, start: start2, stop: stop2 }, vocabApi, termSampleTypes));
+  });
+  return blockInstance;
+}
+function parseCoordCandidates(prompt2) {
+  const m = /^\s*(\w+)\s*:\s*([\d,]+)\s*-\s*([\d,]+)\s*$/.exec(prompt2);
+  if (!m) return null;
+  const [, chrToken, start, stop] = m;
+  const chrCandidates = /^chr/i.test(chrToken) ? [chrToken, chrToken.replace(/^chr/i, "")] : [chrToken, "chr" + chrToken];
+  return chrCandidates.map((chr) => `${chr}:${start}-${stop}`);
+}
+async function handleOmnisearchKeyup(self, event) {
+  if (keyupEnter(event)) return;
+  const prompt2 = event.target.value.trim();
+  if (!prompt2) {
+    self.dom.noMatchShown = false;
+    self.clear({ hide: true });
+    return;
+  }
+  const coordCandidates = parseCoordCandidates(prompt2);
+  if (coordCandidates || MIN_PROMPT_LENGTH_FOR_GENE_SEARCH <= prompt2.length && prompt2.length <= MAX_PROMPT_LENGTH_FOR_OMNISEARCH) {
+    try {
+      await doSearch(self, prompt2, coordCandidates);
+    } catch (e) {
+      if (e.stack) console.log(e.stack);
+      sayerror(self.dom.resultDiv, "Error: " + (e.message || e));
+    }
+  } else {
+    self.dom.noMatchShown = false;
+    self.clear({ hide: true });
+  }
+}
+async function fetchOmnisearch(opts) {
+  const data = await dofetch3("termdb/chat", {
+    body: {
+      genome: opts.genome,
+      dslabel: opts.dslabel,
+      omnisearch: true,
+      prompt: opts.prompt,
+      cohortStr: opts.cohortStr,
+      usecase: opts.usecase,
+      treeFilter: opts.treeFilter,
+      coordCandidates: opts.coordCandidates || void 0,
+      // gene search runs from 1 char; dictionary + sample search only once the prompt reaches the
+      // longer cutoff, so the server skips them (and their all-samples scan) for short prompts
+      includeDictAndSampleSearch: opts.prompt.trim().length >= MIN_PROMPT_LENGTH_FOR_OTHER_SEARCH
+    }
+  });
+  if (data.error) throw data.error;
+  return data;
+}
+function renderOmnisearchResults(self, data) {
+  const coord = data.coord || null;
+  const dictItems = Array.isArray(data.dictionaryTerms) ? data.dictionaryTerms : [];
+  const genes = Array.isArray(data.genes) ? data.genes : [];
+  const dictNames = new Set(dictItems.map((t) => t.name?.toUpperCase()));
+  const geneMap = /* @__PURE__ */ new Map();
+  for (const g of genes) {
+    const gene = g?.gene;
+    if (!gene || dictNames.has(gene.toUpperCase())) continue;
+    const dt = g.dataTypes || {};
+    const geneVariantTypes = [];
+    if (dt.snvindel) geneVariantTypes.push({ label: "SNV/indel", testid: "snvindel", dtCandidates: [dtsnvindel] });
+    if (dt.cnv) geneVariantTypes.push({ label: "CNV", testid: "cnv", dtCandidates: [dtcnv] });
+    if (dt.svfusion)
+      geneVariantTypes.push({ label: "SV/fusion", testid: "svfusion", dtCandidates: [dtsv, dtfusionrna] });
+    const entry = { name: gene, gene, isGene: true };
+    if (dt.geneExpression) entry.isGeneExpression = true;
+    if (geneVariantTypes.length) {
+      entry.isGeneVariant = true;
+      entry.geneVariantTypes = geneVariantTypes;
+    }
+    if (dt.genomeBrowser) {
+      entry.isGenomeBrowser = true;
+      entry.coord = g.coord;
+    }
+    if (dt.dnaMethylation) {
+      entry.isMethylation = true;
+      entry.coord = g.coord;
+    }
+    if (entry.isGeneExpression || entry.isGeneVariant || entry.isGenomeBrowser || entry.isMethylation) {
+      geneMap.set(gene.toUpperCase(), entry);
+    }
+  }
+  const geneItems = [...geneMap.values()];
+  const sampleItems = (Array.isArray(data.samples) ? data.samples : []).filter((s) => s?.name).map((s) => ({
+    isSample: true,
+    name: s.name,
+    sampleId: s.id,
+    singleCell: s.singleCell,
+    facetTracks: s.assays,
+    wsimages: s.wsimages
+  }));
+  const coordItems = coord ? [{ isCoord: true, name: `${coord.chr}:${coord.start.toLocaleString()}-${coord.stop.toLocaleString()}`, coord }] : [];
+  const totals = data.totals || {};
+  const lst = [];
+  for (const group of [
+    {
+      key: "dictionary",
+      heading: "Dictionary",
+      noun: "dictionary variable",
+      items: dictItems,
+      returned: dictItems.length,
+      total: totals.dictionaryTerms
+    },
+    {
+      key: "genes",
+      heading: "Genes",
+      noun: "gene",
+      items: geneItems,
+      returned: Array.isArray(data.genes) ? data.genes.length : 0,
+      total: totals.genes
+    },
+    {
+      key: "samples",
+      heading: "Samples",
+      noun: "sample",
+      items: sampleItems,
+      returned: sampleItems.length,
+      total: totals.samples
+    },
+    {
+      key: "coord",
+      heading: "Genomic region",
+      noun: "",
+      items: coordItems,
+      returned: coordItems.length,
+      total: void 0
+    }
+  ]) {
+    if (!group.items.length) continue;
+    lst.push({ isHeading: true, name: group.heading });
+    for (const item of group.items) lst.push(item);
+    if (typeof group.total == "number" && group.total > group.returned) {
+      lst.push({
+        isNote: true,
+        testid: `sjpp-mass-chat-note-${group.key}`,
+        name: `Displaying ${group.items.length} out of a total of ${group.total} ${group.noun} matches`
+      });
+    }
+  }
+  if (!lst.length) {
+    if (!self.dom.noMatchShown) {
+      self.dom.noMatchShown = true;
+      self.noResult();
+    }
+  } else {
+    self.dom.noMatchShown = false;
+    self.showTerms({ lst });
+  }
+}
+async function doSearch(self, prompt2, coordCandidates) {
+  if (!prompt2) {
+    self.clear({ hide: true });
+    return;
+  }
+  const seq = self.omnisearchSeq = (self.omnisearchSeq || 0) + 1;
+  const data = await fetchOmnisearch({
+    genome: self.app.vocabApi.vocab.genome,
+    dslabel: self.app.vocabApi.vocab.dslabel,
+    prompt: prompt2,
+    cohortStr: self.getState(self.app.getState()).cohortStr,
+    usecase: self.opts.usecase,
+    treeFilter: self.app.vocabApi.state?.treeFilter,
+    coordCandidates
+  });
+  if (seq !== self.omnisearchSeq) return;
+  renderOmnisearchResults(self, data);
+}
+function setSearchRenderers(self) {
+  let text = "No match";
+  if (self.isChat) {
+    text = "No match. Using the chatbot...";
+  }
+  self.noResult = () => {
+    self.clear();
+    self.dom.resultDiv.append("div").text(text).style("padding", "3px 3px 3px 0px").style("opacity", 0.5);
+    clearTimeout(self.noResultTimer);
+    self.noResultTimer = setTimeout(() => {
+      self.clear({ hide: true });
+    }, 1500);
+  };
+  self.showTerms = (data) => {
+    clearTimeout(self.noResultTimer);
+    if (self.opts.disable_terms)
+      data.lst.forEach((t) => {
+        if (t.disabled) self.opts.disable_terms.push(t);
+      });
+    self.clear({ hide: !data.lst.length });
+    if (data.lst.length) {
+      self.dom.resultDiv.append("table").selectAll().data(data.lst).enter().append("tr").each(self.showTerm);
+    }
+  };
+  self.launchPlot = async (config) => {
+    if (self.state?.nav?.activeTab == 0) {
+      await self.app.dispatch({ type: "tab_set", activeTab: 1 });
+    }
+    self.app.dispatch({ type: "plot_create", config });
+    self.dom.inputNode.value = "";
+    self.clear({ hide: true });
+  };
+  self.launchGeneVariantPlot = async (gene, dtCandidates) => {
+    let tw;
+    let lastErr;
+    for (const dt of dtCandidates) {
+      const candidate = {
+        term: {
+          id: gene,
+          name: gene,
+          genes: [{ kind: "gene", id: gene, gene, name: gene, type: "geneVariant" }],
+          type: "geneVariant"
+        },
+        q: { type: "predefined-groupset", dtLst: [dt] }
+      };
+      try {
+        await fillTermWrapper(candidate, self.app.vocabApi);
+        tw = candidate;
+        break;
+      } catch (e) {
+        lastErr = e;
+      }
+    }
+    if (!tw) throw lastErr;
+    await self.launchPlot({ chartType: "summary", term: tw });
+  };
+  self.launchGenomeBrowserView = async (mode, opts) => {
+    if (mode == "protein") {
+      if (!opts.gene) throw new Error("gene symbol required for protein view");
+      await self.launchPlot({
+        chartType: "genomeBrowser",
+        geneSearchResult: { geneSymbol: opts.gene },
+        blockIsProteinMode: true
+      });
+      return;
+    }
+    if (!opts.coord) throw new Error("coordinate required for genomic view");
+    await self.launchPlot({
+      chartType: "genomeBrowser",
+      geneSearchResult: { chr: opts.coord.chr, start: opts.coord.start, stop: opts.coord.stop },
+      blockIsProteinMode: false
+    });
+  };
+  self.launchGenomeBrowser = async (gene, coord) => {
+    const gbRestrictMode = self.app.getState().termdbConfig?.queries?.gbRestrictMode;
+    if (gbRestrictMode == "protein") {
+      await self.launchGenomeBrowserView("protein", { gene });
+      return;
+    }
+    if (gbRestrictMode == "genomic") {
+      if (!coord) throw new Error(`Unable to resolve genomic coordinates for gene "${gene}".`);
+      await self.launchGenomeBrowserView("genomic", { coord });
+      return;
+    }
+    self.dom.tip.clear();
+    self.dom.tip.showunder(self.dom.inputNode);
+    const holder = self.dom.resultDiv.append("div").style("margin", "10px");
+    holder.append("div").style("margin-bottom", "5px").text(gene);
+    const btndiv = holder.append("div");
+    const addViewBtn = (label, testid, mode) => {
+      btndiv.append("button").attr("data-testid", testid).style("margin-right", "10px").text(label).on(
+        "click",
+        () => void self.launchGenomeBrowserView(mode, { gene, coord }).catch((e) => sayerror(self.dom.resultDiv, "Error: " + (e?.message || e)))
+      );
+    };
+    addViewBtn(`Protein view of ${gene}`, `sjpp-mass-chat-gb-protein-${gene}`, "protein");
+    if (coord) addViewBtn(`Genomic view of ${gene}`, `sjpp-mass-chat-gb-genomic-${gene}`, "genomic");
+  };
+  self.launchMethylationPlot = async (gene, coord) => {
+    if (!coord) throw new Error(`Could not resolve coordinates for gene "${gene}"`);
+    self.dom.tip.clear();
+    self.dom.tip.showunder(self.dom.inputNode);
+    const holder = self.dom.resultDiv.append("div").style("margin", "10px");
+    holder.append("div").style("margin-bottom", "5px").text(gene);
+    await embedMethylationRegionPicker({
+      holder: holder.append("div"),
+      genomeObj: self.app.opts.genome,
+      vocabApi: self.app.vocabApi,
+      chr: coord.chr,
+      start: coord.start,
+      stop: coord.stop,
+      callback: async (term) => {
+        await self.launchPlot({ chartType: "summary", term: { term } });
+      }
+    });
+  };
+  self.launchSurvivalWithCovariate = async (covariateField, covariateTw) => {
+    self.dom.tip.clear();
+    self.dom.tip.showunder(self.dom.inputNode);
+    const action = { type: "plot_create", config: { chartType: "survival", [covariateField]: covariateTw } };
+    const termdb = await import("./app-SZDIV5U4.js");
+    termdb.appInit({
+      vocabApi: self.app.vocabApi,
+      holder: self.dom.tip.d.append("div"),
+      state: { nav: { header_mode: "search_only" }, tree: { usecase: { target: "survival", detail: "term" } } },
+      tree: {
+        click_term: (term) => {
+          action.config.term = term.term ? term : { term };
+          self.dom.tip.hide();
+          self.app.dispatch(action);
+        }
+      }
+    });
+  };
+  self.renderGeneCategories = (holder, item) => {
+    const hasSurvival = self.app.vocabApi.termdbConfig?.allowedTermTypes?.includes("survival");
+    const addRow = (label) => {
+      const row = holder.append("div").style("margin", "4px 0");
+      row.append("span").style("font-weight", "bold").style("margin-right", "8px").text(label + ":");
+      return row;
+    };
+    const addBtn = (row, label, testid, onClick) => {
+      row.append("span").attr("class", "sja_menuoption").attr("data-testid", testid).style("display", "inline-block").style("margin", "0px 3px").style("padding", "5px 10px").style("border-radius", "5px").style("cursor", "pointer").text(label).on("click", () => void onClick().catch((e) => sayerror(self.dom.resultDiv, "Error: " + (e?.message || e))));
+    };
+    if (item.isGeneExpression) {
+      const row = addRow("Gene Expression");
+      addBtn(row, "Summary", `sjpp-mass-chat-gene-exp-${item.gene}`, async () => {
+        await self.launchPlot({
+          chartType: "summary",
+          term: { term: { gene: item.gene, name: item.name, type: "geneExpression" } }
+        });
+      });
+      if (hasSurvival) {
+        addBtn(row, "Survival", `sjpp-mass-chat-gene-exp-survival-${item.gene}`, async () => {
+          await self.launchSurvivalWithCovariate("term2", {
+            term: { gene: item.gene, name: item.name, type: "geneExpression" }
+          });
+        });
+      }
+    }
+    if (item.isGeneVariant) {
+      const label = (item.geneVariantTypes || []).map((vt) => vt.label).join("/");
+      const allDtCandidates = (item.geneVariantTypes || []).flatMap((vt) => vt.dtCandidates);
+      const row = addRow(label);
+      addBtn(row, "Summary", `sjpp-mass-chat-gene-variant-${item.gene}`, async () => {
+        await self.launchGeneVariantPlot(item.gene, allDtCandidates);
+      });
+      addBtn(row, "Protein view", `sjpp-mass-chat-gene-protein-${item.gene}`, async () => {
+        await self.launchGenomeBrowserView("protein", { gene: item.gene });
+      });
+      addBtn(row, "Genome view", `sjpp-mass-chat-gene-genomic-${item.gene}`, async () => {
+        await self.launchGenomeBrowserView("genomic", { coord: item.coord });
+      });
+    }
+    if (item.isMethylation) {
+      const row = addRow("DNA methylation");
+      addBtn(row, "Summary", `sjpp-mass-chat-gene-methylation-${item.gene}`, async () => {
+        await self.launchMethylationPlot(item.gene, item.coord);
+      });
+    }
+  };
+  self.showTerm = function(item) {
+    const tr = select_default(this);
+    if (item.isHeading) {
+      tr.append("td").attr("colspan", 2).attr("data-testid", `sjpp-mass-chat-heading-${item.name.toLowerCase().replace(/\s+/g, "-")}`).text(item.name).style("padding", "6px 10px 2px").style("font-weight", "bold").style("font-size", "0.85em").style("text-transform", "uppercase").style("opacity", 0.5);
+      return;
+    }
+    if (item.isNote) {
+      tr.append("td").attr("colspan", 2).attr("data-testid", item.testid || "sjpp-mass-chat-note").text(item.name).style("padding", "2px 10px 6px").style("font-size", "0.8em").style("font-style", "italic").style("opacity", 0.6);
+      return;
+    }
+    if (item.isCoord) {
+      tr.append("td").text(item.name).style("padding", "5px 10px");
+      tr.append("td").append("span").attr("class", "sja_menuoption").attr("data-testid", "sjpp-mass-chat-coord-genomebrowser").style("display", "inline-block").style("margin", "0px 3px").style("padding", "5px 10px").style("border-radius", "5px").style("cursor", "pointer").text("Genome Browser").on(
+        "click",
+        () => void self.launchGenomeBrowserView("genomic", { coord: item.coord }).catch((e) => sayerror(self.dom.resultDiv, "Error: " + (e?.message || e)))
+      );
+      return;
+    }
+    if (item.isSample) {
+      tr.append("td").text(item.name).style("padding", "5px 10px");
+      tr.append("td").append("span").attr("class", "sja_menuoption").attr("data-testid", `sjpp-mass-chat-sample-view-${item.sampleId}`).style("display", "inline-block").style("margin", "0px 3px").style("padding", "5px 10px").style("border-radius", "5px").style("cursor", "pointer").text("Sample View").on(
+        "click",
+        () => void self.launchPlot({
+          chartType: "sampleView",
+          sample: { sampleId: item.sampleId, sampleName: item.name }
+        }).catch((e) => sayerror(self.dom.resultDiv, "Error: " + (e?.message || e)))
+      );
+      if (item.singleCell) {
+        tr.select("td:nth-child(2)").append("button").attr("type", "button").attr("class", "sja_menuoption").attr("data-testid", `sjpp-mass-chat-single-cell-${item.sampleId}`).style("display", "inline-block").style("margin", "0px 3px").style("padding", "5px 10px").style("border-radius", "5px").style("border", "0").style("cursor", "pointer").text("Single cell").on(
+          "click",
+          () => void self.launchPlot({
+            chartType: "sc",
+            settings: { sc: { item: item.singleCell } }
+          }).catch((e) => sayerror(self.dom.resultDiv, "Error: " + (e?.message || e)))
+        );
+      }
+      if (item.wsimages) {
+        tr.select("td:nth-child(2)").append("button").attr("type", "button").attr("class", "sja_menuoption").attr("data-testid", `sjpp-mass-chat-wsimages-${item.sampleId}`).style("display", "inline-block").style("margin", "0px 3px").style("padding", "5px 10px").style("border-radius", "5px").style("border", "0").style("cursor", "pointer").text("Whole Slide Images").on(
+          "click",
+          () => void self.launchPlot({
+            chartType: "wsi",
+            sample: { sID: item.name },
+            imageType: "wsi"
+          }).catch((e) => sayerror(self.dom.resultDiv, "Error: " + (e?.message || e)))
+        );
+      }
+      if (item.facetTracks?.length) {
+        tr.select("td:nth-child(2)").append("button").attr("type", "button").attr("class", "sja_menuoption").attr("data-testid", `sjpp-mass-chat-assays-${item.sampleId}`).style("display", "inline-block").style("margin", "0px 3px").style("padding", "5px 10px").style("border-radius", "5px").style("cursor", "pointer").text("Facet Table").on(
+          "click",
+          () => void self.launchPlot({
+            chartType: "genomeBrowser",
+            hidePlotFilter: true,
+            filter: getSampleFilter(item.sampleId)
+          }).catch((e) => sayerror(self.dom.resultDiv, "Error: " + (e?.message || e)))
+        );
+      }
+      return;
+    }
+    if (item.isGene) {
+      tr.append("td").text(item.name).style("padding", "5px 10px").style("cursor", "pointer").attr("class", "sja_menuoption").attr("data-testid", `sjpp-mass-chat-gene-select-${item.gene}`).on("click", () => {
+        self.dom.inputNode.value = "";
+        self.clear({ hide: true });
+        self.addBubble({ msg: escapeHtml(item.name) + " (gene)", me: 1 });
+        const holder = self.addBubble({ msg: "" });
+        self.renderGeneCategories(holder, item);
+      });
+      return;
+    }
+    const button = tr.append("td").text(item.name);
+    if (item.type) {
+      button.style("cursor", "pointer").attr("class", "sja_menuoption").attr("data-testid", `sjpp-mass-chat-term-${item.id}`).on("click", async () => {
+        self.addBubble({ msg: escapeHtml(item.name) + " (dictionary variable)", me: 1 });
+        await self.launchPlot({
+          chartType: item.type == "survival" ? "survival" : "summary",
+          term: { term: item }
+        });
+      });
+    } else {
+      button.style("padding", "5px 10px").style("opacity", 0.5);
+    }
+    tr.append("td").text((item.__ancestorNames || []).join(" > ")).style("opacity", 0.5).style("font-size", ".7em");
+  };
+  self.clear = (opts = {}) => {
+    self.dom.tip.clear();
+    if (opts.hide) self.dom.tip.hide();
+    else self.dom.tip.showunder(self.dom.inputNode);
+  };
+}
+
+// mass/chat.ts
+var MIN_PROMPT_LENGTH_FOR_CHAT = 5;
+var MassAiChatBot = class _MassAiChatBot {
+  static {
+    this.type = "chat";
+  }
+  constructor(opts) {
+    this.type = _MassAiChatBot.type;
+    this.opts = opts;
+    this.app = opts.app;
+    this.opts.usecase = this.opts.usecase || { target: "dictionary", detail: "term" };
+    this.opts.targetType = this.opts.targetType ? this.opts.targetType : "Dictionary Variables";
+    this.isChat = this.app.getState().termdbConfig?.queries?.chat;
+    setSearchRenderers(this);
+  }
+  getState(appState) {
+    return {
+      cohortStr: appState.activeCohort == -1 || !appState.termdbConfig.selectCohort ? "" : appState.termdbConfig.selectCohort.values[appState.activeCohort].keys.slice().sort().join(","),
+      search: appState.search,
+      nav: appState.nav
+    };
+  }
+  async init() {
+    this.initDom();
+  }
+  initDom() {
+    let text = "Search an item";
+    let height = "auto";
+    if (this.isChat) {
+      text = "Ask a question";
+      height = "200px";
+    }
+    this.dom = {
+      tip: new Menu({ padding: "5px" }),
+      div: this.opts.subheader,
+      error: this.opts.subheader.append("div").attr("id", "sjpp-corrVolcano-error").style("opacity", 0.75),
+      bubbleDiv: this.opts.subheader.append("div").attr("class", "sjpp_show_scrollbar").style("margin", "5px 20px 0px 20px").style("height", height).style("max-height", "200px").style("overflow", "auto").style("scroll-behavior", "smooth")
+    };
+    const inputSel = this.dom.div.append("input").attr("type", "search").attr("data-testid", "sjpp-mass-omnisearch-input").style("margin", "15px").style("padding", "17px").style("border-radius", "34px").attr("size", 70).attr("placeholder", text);
+    this.dom.inputNode = inputSel.node();
+    this.dom.resultDiv = this.dom.tip.d.style("border-left", "solid 1px rgb(133,182,225)").style("padding-left", "5px").attr("tabindex", -1);
+    inputSel.on("keyup.search", (event) => handleOmnisearchKeyup(this, event)).on("keyup.submit", async (event) => {
+      if (!keyupEnter(event)) return;
+      if (!this.isChat) {
+        return;
+      }
+      const prompt2 = event.target.value.trim();
+      if (!prompt2) return;
+      this.addBubble({ msg: escapeHtml(prompt2), me: 1 });
+      event.target.value = "";
+      const serverBubble = this.addBubble({ msg: "..." });
+      if (prompt2.length <= MIN_PROMPT_LENGTH_FOR_CHAT) {
+        serverBubble.text("Your prompt is too short. Enter a longer prompt.");
+        return;
+      }
+      const body = {
+        genome: this.app.vocabApi.vocab.genome,
+        dslabel: this.app.vocabApi.vocab.dslabel,
+        filter: this.app.vocabApi.state.termfilter?.filter,
+        prompt: prompt2
+      };
+      try {
+        const data = await dofetch3("termdb/chat", { body });
+        if (data.error) throw data.error;
+        const result = data;
+        if (result.type === "text") {
+          serverBubble.text(result.text);
+        } else if (result.type === "html") {
+          serverBubble.html(result.html);
+        } else if (result.type === "plot") {
+          const optionField = findPossibleOptionsField(result.plot);
+          if (optionField) {
+            this.showPossibleOptions(serverBubble, result.plot, optionField, result.msg);
+          } else {
+            this.app.dispatch({
+              type: "plot_create",
+              config: result.plot
+            });
+            serverBubble.text(`${result.msg ? result.msg + ". " : ""}Please refer to the plot generated below.`);
+          }
+        }
+      } catch (e) {
+        if (e.stack) console.log(e.stack);
+        serverBubble.html(`Error: ${e.message || e}`);
+      }
+    }).node().focus();
+  }
+  addBubble(arg) {
+    const bubble = this.dom.bubbleDiv.append("div").style("padding", "10px").html(`${arg.me ? '<span style="font-size:.7em">[ME]</span> ' : ""}${arg.msg}`);
+    if (arg.me) bubble.style("background", "#f1f1f1");
+    const n = this.dom.bubbleDiv.node();
+    n.scrollTop = n.scrollHeight;
+    return bubble;
+  }
+  // Render click boxes for an incomplete plot state. `fieldKey` is the field of `plot` whose
+  // value holds `possible_options`. Clicking a box completes the plot state and dispatches plot_create.
+  // Each option completes the plot in one of two ways:
+  //  - opt.config: a config patch merged into the plot (the incomplete field is dropped). Used when the
+  //    choice sets other fields, e.g. the genome browser view sets blockIsProteinMode: true|false.
+  //  - otherwise: the incomplete field is set to { id: opt.id }, e.g. survival term selection -> term:{id}.
+  showPossibleOptions(bubble, plot, fieldKey, msg) {
+    const options = plot[fieldKey].possible_options || [];
+    bubble.text(`${msg ? msg + ". " : ""}Multiple options are available. Please select one:`);
+    const boxDiv = bubble.append("div").style("margin-top", "5px");
+    for (const opt of options) {
+      boxDiv.append("div").attr("class", "sja_menuoption").attr("data-testid", `sjpp-mass-chat-option-${opt.id}`).style("display", "inline-block").style("margin", "3px").style("padding", "5px 10px").style("border-radius", "5px").style("cursor", "pointer").text(opt.name).on("click", () => {
+        const config = JSON.parse(JSON.stringify(plot));
+        if (opt.config) {
+          delete config[fieldKey];
+          Object.assign(config, opt.config);
+        } else {
+          config[fieldKey] = { id: opt.id };
+        }
+        this.app.dispatch({
+          type: "plot_create",
+          config
+        });
+        bubble.selectAll("*").remove();
+        bubble.text(`Selected "${opt.name}". Please refer to the plot generated below.`);
+      });
+    }
+  }
+  main() {
+    if (this.opts.subheader.style("display") == "none") {
+      this.dom.inputNode.blur();
+      this.dom.tip.hide();
+      return;
+    }
+    if (this.opts?.focus != "off") this.dom.inputNode.focus();
+  }
+};
+var chatInit = getCompInit(MassAiChatBot);
+function findPossibleOptionsField(plot) {
+  if (!plot || typeof plot !== "object") return null;
+  for (const key of Object.keys(plot)) {
+    const val = plot[key];
+    if (val && typeof val === "object" && Array.isArray(val.possible_options)) return key;
+  }
+  return null;
+}
+
+// mass/user.ts
+function datasetRequiresAuth(termdbConfig) {
+  return !!termdbConfig?.requiredAuth?.length;
+}
+function getUserTabContent(userTab2, activeCohort) {
+  return activeCohort != null && userTab2?.byCohort?.[activeCohort] || userTab2;
+}
+function getAuthStatus(signedIn, isPublic) {
+  if (!signedIn) return "Requires sign-in";
+  return isPublic === true ? "Public access" : "You are signed in.";
+}
+function getDaysLeft(days) {
+  if (typeof days != "number" || !Number.isFinite(days)) return;
+  return {
+    text: `${days} ${days == 1 ? "day" : "days"} left`,
+    tip: 'The server keeps a session opened from a link for a limited time, and removes it when the days run out. To keep your work, select "Save" in this tab to create a new session, then use "Share" to get its link.'
+  };
+}
+var MassUser = class _MassUser {
+  constructor(opts) {
+    /** The termdb route that is checked for a required credential */
+    this.route = "termdb";
+    /** Sessions saved in this browser, by session name. Mirrors localStorage 'savedMassSessions' */
+    this.savedSessions = {};
+    /** Whether the user was signed in at the last check, to detect a sign-in after the launch */
+    this.signedIn = false;
+    this.type = _MassUser.type;
+    this.opts = opts;
+    this.app = opts.app;
+    this.subheader = opts.subheader;
+    const sessionDiv = this.subheader.append("div").attr("data-testid", "sjpp-massnav-user-session");
+    sessionDiv.append("span").attr("data-testid", "sjpp-massnav-user-session-label").style("margin", "0 10px").style("font-weight", "bold").style("opacity", 0.65).text("SESSION");
+    this.dom = {
+      authDiv: this.subheader.append("div").attr("data-testid", "sjpp-massnav-user-auth").style("margin", "10px"),
+      sessionDiv,
+      // inline-flex, to be on the same row as the label, with the same gap between the buttons
+      optionsDiv: sessionDiv.append("div").attr("data-testid", "sjpp-massnav-user-session-options").style("display", "inline-flex").style("vertical-align", "middle").style("gap", "10px"),
+      // aligned with the edge of the option buttons, which have a 10px margin
+      contentDiv: sessionDiv.append("div").attr("id", "sjpp-massnav-user-session-menu").attr("data-testid", "sjpp-massnav-user-session-content").style("margin", "0 10px"),
+      copytip: new Menu({ padding: "5px" })
+    };
+    this.sessionOptions = [
+      { label: `Open`, icon: "&#x23CF;&#xFE0E;", title: "Recover a saved session", callback: () => this.open() },
+      { label: `Save`, icon: "&#x2B07;&#xFE0E;", title: "Save the current view", callback: () => this.save() },
+      {
+        label: `Share`,
+        icon: "&#x26D3;&#xFE0E;",
+        title: "Share the current view",
+        callback: () => this.getSessionUrl()
+      }
+    ];
+    this.embedderOrigin = window.location.origin;
+    this.hostURL = sessionStorage.getItem("hostURL") || this.embedderOrigin;
+  }
+  static {
+    this.type = "user";
+  }
+  /**
+   * By default, only what this component renders from. rx compares the returned object with the previous state
+   * on every dispatch, so it must not include the whole termdbConfig, which can be very large.
+   *
+   * forSession=true: the parts of the app state that make up a saved session instead, copied so that the app
+   * state, which is deeply frozen and shared, is not changed. app_refresh merges a reopened session into the
+   * current state, so what is not saved, such as the dataset config that init() in mass/store.ts fetches
+   * again, keeps its current value. The derived properties of a geneVariant term are re-filled by every path
+   * that opens a session, see trimGvTermsForSave().
+   */
+  getState(appState, forSession = false) {
+    if (forSession) {
+      const { vocab, activeCohort, termfilter, plots, groups, customTerms, reuse, nav } = appState;
+      const state = structuredClone({ vocab, activeCohort, termfilter, plots, groups, customTerms, reuse, nav });
+      return markSavedState(trimGvTermsForSave(state));
+    }
+    return {
+      activeCohort: appState.activeCohort,
+      termdbConfig: {
+        requiredAuth: appState.termdbConfig?.requiredAuth,
+        massNav: { tabs: { user: appState.termdbConfig?.massNav?.tabs?.user } }
+      }
+    };
+  }
+  /** Adds the methods that nav.ts calls on the api, since only the api is available outside the component */
+  preApiFreeze(api) {
+    api.showDaysLeftTip = (e) => {
+      const tip = getDaysLeft(this.opts.sessionDaysLeft)?.tip;
+      if (!tip) return;
+      this.dom.copytip.clear().d.append("div").style("max-width", "300px").text(tip);
+      const p = e.getBoundingClientRect();
+      this.dom.copytip.show2(p.left, p.bottom + 5);
+    };
+    api.hideDaysLeftTip = () => this.dom?.copytip?.hide();
+  }
+  async init(appState) {
+    this.dslabel = appState.vocab.dslabel;
+    this.savedSessions = JSON.parse(localStorage.getItem("savedMassSessions") || `{}`);
+    this.setRequiredAuth(appState.termdbConfig);
+    this.initSessionOptions();
+  }
+  async main() {
+    this.setRequiredAuth(this.state.termdbConfig);
+    this.renderAuthInfo();
+    this.mayLookupAfterSignIn();
+  }
+  /**
+   * The sessions on the server are not looked up while the user is not signed in. So when the user signs in
+   * after the launch, look them up then. Only a change to signed in triggers this, so that a lookup that keeps
+   * failing is not repeated on every update of the app.
+   */
+  mayLookupAfterSignIn() {
+    const signedIn = !!this.app.vocabApi.hasVerifiedToken();
+    const justSignedIn = signedIn && !this.signedIn;
+    this.signedIn = signedIn;
+    if (justSignedIn && this.requiredAuth && !this.serverCachedSessions) {
+      this.setServerCachedSessions();
+    }
+  }
+  setRequiredAuth(termdbConfig) {
+    this.requiredAuth = termdbConfig?.requiredAuth?.find((a) => a.route == this.route && a.type == "jwt");
+  }
+  /** Show the sign-in status when the dataset requires authorization. Hidden for a public dataset */
+  renderAuthInfo() {
+    const div = this.dom.authDiv;
+    div.selectAll("*").remove();
+    if (!datasetRequiresAuth(this.state.termdbConfig)) {
+      div.style("display", "none");
+      return;
+    }
+    div.style("display", "block");
+    const vocabApi = this.app.vocabApi;
+    const signedIn = vocabApi.hasVerifiedToken();
+    const userTab2 = getUserTabContent(this.state.termdbConfig.massNav?.tabs?.user, this.state.activeCohort);
+    const row = div.append("div");
+    row.append("span").attr("data-testid", "sjpp-massnav-user-auth-label").style("font-weight", "bold").style("opacity", 0.65).text("ACCESS");
+    row.append("span").attr("data-testid", "sjpp-massnav-user-auth-status").style("margin-left", "10px").text(userTab2?.status || getAuthStatus(signedIn, userTab2?.isPublic));
+    const msg = vocabApi.tokenVerificationMessage;
+    if (!signedIn && msg) row.append("span").style("margin-left", "5px").style("opacity", 0.65).text(msg);
+    if (userTab2?.msgs?.length) {
+      const table = table2col({ holder: div, margin: "2px 8px", testid: "sjpp-massnav-user-auth-info" });
+      for (const m of userTab2.msgs) {
+        const [td1, td2] = table.addRow(m.label);
+        const target = m.email ? `mailto:${m.email}` : m.link;
+        if (target) {
+          const a = td2.append("a").attr("href", target).text(m.email || m.link);
+          if (m.link) a.attr("target", "_blank");
+        } else if (m.label) {
+          td2.text(m.txt);
+        } else {
+          td2.remove();
+          td1.attr("colspan", 2).style("color", null).text(m.txt);
+        }
+      }
+    }
+    if (userTab2?.list) {
+      const listDiv = div.append("div").attr("data-testid", "sjpp-massnav-user-auth-list").style("margin", "5px 0 0 8px").style("font-size", "0.95em");
+      listDiv.append("div").style("font-weight", "bold").text(userTab2.list.label);
+      const ul = listDiv.append("ul").style("margin", "3px 0");
+      for (const item of userTab2.list.items) ul.append("li").text(item);
+    }
+  }
+  /**
+   * Renders the session options right away. The lookup of the sessions on the server is optional, so it
+   * is not awaited, since it must not delay or block the launch of the mass ui. The options are
+   * rendered again when any lookup is done, since Delete is only shown when there is a session to delete.
+   */
+  initSessionOptions() {
+    this.signedIn = !!this.app.vocabApi.hasVerifiedToken();
+    this.renderSessionOptions();
+    if (!this.serverCachedSessions) this.setServerCachedSessions();
+  }
+  /** The Open, Save, Share, Delete, and Download options. Delete is only available if there is something to delete */
+  getSessionOptions() {
+    const options = this.sessionOptions.slice();
+    if (Object.keys(this.savedSessions).length || this.serverCachedSessions?.length) {
+      options.push({
+        label: `Delete`,
+        icon: "&#x2715;",
+        title: "Delete a saved session",
+        callback: () => this.delete()
+      });
+    }
+    if (this.opts.sessionDaysLeft != null && this.opts.sessionId) {
+      options.push({
+        label: `Download`,
+        icon: "&#x2913;",
+        title: "Download this session as a file",
+        callback: () => this.download(this.opts.sessionId.replace(/[^\w-]/g, "_"), this.getState(this.app.getState(), true))
+      });
+    }
+    return options;
+  }
+  /** Render the buttons of the session options */
+  renderSessionOptions() {
+    if (!this.dom?.optionsDiv) return;
+    const options = this.getSessionOptions();
+    this.dom.optionsDiv.selectAll("*").remove();
+    this.dom.optionsDiv.selectAll("button").data(options).enter().append("button").style("margin", "10px 0").style("padding", "10px 15px").style("border-radius", "20px").style("border-color", "#ededed").attr(
+      "data-testid",
+      (d) => `sjpp-massnav-user-session-btn-${d.label.toLowerCase().replace(/\s/g, "-")}`
+    ).attr("aria-label", (d) => d.title).attr("title", (d) => d.title).html((d) => `${d.icon} ${d.label}`).on("click", async (event, d) => {
+      event.stopPropagation();
+      this.clearContent();
+      await d.callback();
+      if (this.dom?.contentDiv?.node()?.hasChildNodes()) this.dom.contentDiv.style("padding-bottom", "10px");
+    });
+  }
+  clearContent() {
+    clearTimeout(this.confirmationTimer);
+    this.confirmationTimer = void 0;
+    this.dom.contentDiv.interrupt();
+    this.dom.contentDiv.selectAll("*").remove();
+    this.dom.contentDiv.style("opacity", 1).style("padding-bottom", null);
+  }
+  /**
+   * Removes what is not under this.dom of the component, which ComponentApi.destroy() removes. The copytip
+   * Menu is in the document body, with a listener on the body, so it must be destroyed here.
+   */
+  destroy() {
+    clearTimeout(this.copyTipTimer);
+    this.clearContent();
+    this.dom.copytip.destroy();
+  }
+  async open() {
+    const radioName = `sjpp-massnav-user-session-open-radio-` + Math.random().toString().slice(-6);
+    const div = this.dom.contentDiv;
+    div.append("div").style("display", "none").style("padding", "3px 9px").html(`
+					<b>Open in</b>
+					<label>
+						<input type='radio' name='${radioName}' value='new' style='margin-right: 0; vertical-align: bottom'/>
+						<span>a new tab</span>
+					</label>
+					<label style='margin-left: 5px'>
+						<input type='radio' name='${radioName}' value='current' checked=checked style='margin-right: 0; vertical-align: bottom'/>
+						<span>current tab</span>
+					</label>
+				`);
+    const getTargetWindow = () => div.node().querySelector(`[name="${radioName}"]:checked`).value;
+    const t = await this.listSessions({
+      trClickHandler: async (_event, d) => {
+        const { loc, id: id2 } = d;
+        if (!id2) return;
+        if (loc == "browser") {
+          this.sessionName = id2;
+          const state = structuredClone(this.savedSessions[id2]);
+          if (this.refuses(state)) return;
+          await preprocessState(state, this.app);
+          const targetWindow = getTargetWindow();
+          if (targetWindow == "current") {
+            this.app.dispatch({ type: "app_refresh", state });
+          } else if (window.location.origin == this.hostURL) {
+            window.open(`/?mass-session-id=${encodeURIComponent(id2)}&src=browser`);
+          } else {
+            if (state.embedder) parentCorsMessage({ state });
+            else {
+              const { protocol, host, search, origin, href } = window.location;
+              const embedder = { protocol, host, search, origin, href };
+              parentCorsMessage({ state: Object.assign({ embedder }, state) });
+            }
+          }
+          this.clearContent();
+        } else if (loc == "server") {
+          const headers = await this.app.vocabApi.mayGetAuthHeaders(this.route);
+          const body = { id: id2, route: this.route, dslabel: this.dslabel, embedder: window.location.hostname };
+          const res = await dofetch3(`/massSession?`, { headers, body });
+          if (!res.state) throw res.error || "unable to get the cached session from the server";
+          if (this.refuses(res.state)) return;
+          await preprocessState(res.state, this.app);
+          this.savedSessions[id2] = res.state;
+          const targetWindow = getTargetWindow();
+          if (targetWindow == "current") {
+            this.app.dispatch({ type: "app_refresh", state: res.state });
+          } else if (window.location.origin == this.hostURL) {
+            window.open(
+              `/?mass-session-id=${encodeURIComponent(id2)}&src=cred&dslabel=${encodeURIComponent(
+                this.dslabel
+              )}&route=${encodeURIComponent(this.route)}`
+            );
+          } else {
+            parentCorsMessage(res);
+          }
+          this.clearContent();
+        }
+      }
+    });
+    t.headtr.select("th").text("Open from");
+    const tr1 = t.tbody.insert("tr", "tr");
+    tr1.append("td").style("text-align", "center").style("padding", "3px 9px").text("Local file");
+    const label = tr1.append("td").style("text-align", "left").append("label");
+    label.append("span").style("padding", "3px 9px").style("text-decoration", "underline").style("cursor", "pointer").text("Choose File");
+    label.append("input").attr("type", "file").attr("placeholder", "file name").style("opacity", 0).style("width", "0.1px").style("height", "0.1px").style("position", "absolute").on("change", async (event) => {
+      const file = event.target.files.item(0);
+      const json = await file.text();
+      let sessionName = file.name;
+      if (this.savedSessions[sessionName]) {
+        sessionName = prompt(
+          `Leave as-is to overwrite a session with the same name, or enter a different session name.`,
+          sessionName
+        );
+        if (!sessionName) return;
+      }
+      this.sessionName = sessionName;
+      const state = JSON.parse(json);
+      if (this.refuses(state)) return;
+      await preprocessState(state, this.app);
+      this.savedSessions[sessionName] = state;
+      localStorage.setItem("savedMassSessions", JSON.stringify(this.savedSessions));
+      const targetWindow = getTargetWindow();
+      if (targetWindow == "current") {
+        this.app.dispatch({ type: "app_refresh", state });
+      } else if (window.location.origin == this.hostURL) {
+        window.open(`/?mass-session-id=${encodeURIComponent(sessionName)}&src=browser`);
+      } else {
+        if (state.embedder) parentCorsMessage({ state });
+        else {
+          const { protocol, host, search, origin, href } = window.location;
+          const embedder = { protocol, host, search, origin, href };
+          parentCorsMessage({ state: Object.assign({ embedder }, state) });
+        }
+      }
+      this.clearContent();
+    });
+  }
+  async listSessions(opts = {}) {
+    const table = this.dom.contentDiv.append("table").attr("class", "sjpp-controls-table");
+    const headtr = table.append("thead").append("tr");
+    headtr.selectAll("th").data(["Cache Location", "Session ID"]).enter().append("th").style("text-align", (_, i) => i === 0 ? "center" : "left").style("padding", "3px 9px").text((d) => d);
+    const sessionIds = Object.keys(this.savedSessions).map((id2) => ({
+      loc: "browser",
+      id: id2
+    }));
+    if (!this.serverCachedSessions) await this.setServerCachedSessions();
+    sessionIds.push(...(this.serverCachedSessions || []).map((id2) => ({ loc: "server", id: id2 })));
+    const tbody = table.append("tbody");
+    const trs = tbody.selectAll("tr").data(sessionIds).enter().append("tr").on("click", opts.trClickHandler || null);
+    trs.selectAll("td").data((d) => [d, d]).enter().append("td").style("text-align", (_, i) => i === 0 ? "center" : "left").style("padding", "3px 9px").style("cursor", "pointer").text((d, i) => i === 0 ? d.loc : d.id);
+    if (!this.serverCachedSessions?.length && this.requiredAuth && !this.app.vocabApi.hasVerifiedToken()) {
+      table.append("tbody").append("tr").selectAll("td").data(["server", "requires sign-in"]).enter().append("td").style("text-align", (_, i) => i === 0 ? "center" : "left").style("padding", "3px 9px").text((d) => d);
+    }
+    return { table, headtr, tbody, trs };
+  }
+  /**
+   * Looks up the ids of the sessions that the user saved on the server. This never throws, since the
+   * sessions on the server are optional: the sessions of the browser, and everything else in the mass ui,
+   * must work when the lookup fails, for example from a network error or a failure to get a token.
+   *
+   * Only a successful lookup is kept in serverCachedSessions. It stays undefined when the lookup is not made
+   * because the user is not signed in, or when it fails, so that it is tried again on the next use.
+   * Callers that arrive while a lookup is in progress share it instead of sending another request.
+   */
+  setServerCachedSessions() {
+    if (this.serverSessionsRequest) return this.serverSessionsRequest;
+    if (!this.mayLookupSessions()) return Promise.resolve();
+    this.serverSessionsRequest = this.lookupServerSessions().finally(() => {
+      this.serverSessionsRequest = void 0;
+      this.renderSessionOptions();
+    });
+    return this.serverSessionsRequest;
+  }
+  /**
+   * Returns true when the sessions on the server should be looked up now. A dataset without a jwt
+   * credential has none, and the lookup is not made, so serverCachedSessions is an empty list.
+   * It is also not made before the user is signed in, when the server would reject the request.
+   */
+  mayLookupSessions() {
+    try {
+      const state = this.app.getState();
+      this.requiredAuth = state.termdbConfig?.requiredAuth?.find((a) => a.route == this.route && a.type == "jwt");
+      if (!this.requiredAuth) {
+        this.serverCachedSessions = [];
+        return false;
+      }
+      return !!this.app.vocabApi.hasVerifiedToken();
+    } catch (e) {
+      console.warn(`unable to get the sessions saved on the server: ${e?.message || e}`);
+      return false;
+    }
+  }
+  async lookupServerSessions() {
+    try {
+      const headers = await this.app.vocabApi.mayGetAuthHeaders(this.route);
+      const body = { route: this.route, dslabel: this.dslabel, embedder: window.location.hostname };
+      const res = await dofetch3("/sessionIds", { headers, body });
+      if (!Array.isArray(res?.sessionIds)) throw res?.error || "unexpected response";
+      this.serverCachedSessions = res.sessionIds;
+    } catch (e) {
+      console.warn(`unable to get the sessions saved on the server: ${e?.message || e}`);
+    }
+  }
+  async save() {
+    const div = this.dom.contentDiv;
+    const inputDiv = div.append("div");
+    inputDiv.append("span").text("Save as");
+    const sessionNames = Object.keys(this.savedSessions);
+    if (!this.serverCachedSessions) await this.setServerCachedSessions();
+    sessionNames.push(...(this.serverCachedSessions || []).filter((d) => !sessionNames.includes(d)));
+    const placeholder = this.sessionName || "unnamed-session";
+    const input = inputDiv.append("input").attr("type", "text").attr("placeholder", placeholder).style("width", "220px").on("input", () => {
+      searchResultDiv.selectAll("*").remove();
+      const value = input.property("value");
+      const exactMatch = sessionNames.filter((s) => s === value);
+      const startsWith = sessionNames.filter((s) => s.startsWith(value));
+      const includes = sessionNames.filter((s) => s.includes(value) && s !== value && !startsWith.includes(s));
+      searchResultDiv.selectAll("div").data([...exactMatch, ...startsWith, ...includes]).enter().append("div").attr("class", "sja_menuoption").attr("data-testid", `sjpp-massnav-user-session-save-option`).text((d) => d).on("click", (_, d) => {
+        input.property("value", d);
+        searchResultDiv.selectAll("*").remove();
+      });
+    });
+    const searchResultDiv = div.append("div");
+    const submitDiv = div.append("div");
+    submitDiv.append("span").html("Save to&nbsp;");
+    submitDiv.append("button").style("min-width", "80px").text("Browser").attr(
+      "title",
+      `Save the session in your current browser's cache. The session can be easily recovered, but not shared among your other devices`
+    ).on("click", () => {
+      this.sessionName = input.property("value") || placeholder;
+      this.savedSessions[this.sessionName] = this.getState(this.app.getState(), true);
+      localStorage.setItem("savedMassSessions", JSON.stringify(this.savedSessions));
+      this.renderSessionOptions();
+      this.confirmAction(`Cached '${this.sessionName}' in browser`);
+    });
+    submitDiv.append("button").style("min-width", "80px").text("File").attr(
+      "title",
+      `Save the session into a local file. The session can be easily recoved using the 'Open from local file' option.`
+    ).on("click", () => {
+      const name = input.property("value") || placeholder;
+      this.download(name, this.getState(this.app.getState(), true));
+      this.confirmAction(`Downloaded '${name}'`);
+    });
+    if (this.requiredAuth) {
+      const requiresSignIn = this.app.vocabApi.hasVerifiedToken() ? "" : "Requires sign-in. ";
+      submitDiv.append("button").style("min-width", "80px").text("Server").attr(
+        "title",
+        `${requiresSignIn}Save the session into a remote server. The session can be easily shared across your different devices and recovered using the 'Open from server' option.`
+      ).property("disabled", !this.app.vocabApi.hasVerifiedToken()).on("click", async () => {
+        if (!this.app.vocabApi.hasVerifiedToken()) {
+          alert("Requires sign-in");
+          return;
+        }
+        const name = input.property("value") || placeholder;
+        const res = await this.getSessionUrl(name);
+        if (res.error || res.id != name) {
+          sayerror(submitDiv, `Unable to save '${name}' on the server: ${res.error || "unexpected session id"}`);
+          return;
+        }
+        if (this.serverCachedSessions && !this.serverCachedSessions.includes(name))
+          this.serverCachedSessions.push(name);
+        this.renderSessionOptions();
+        this.confirmAction(`Saved '${name}' on the server`);
+      });
+    }
+  }
+  // true when a saved state is not opened, see sessionForm.ts. the reason is shown
+  refuses(state) {
+    const reason = getSavedStateRefusal(state);
+    if (!reason) return false;
+    this.clearContent();
+    this.app.printError(reason);
+    return true;
+  }
+  download(name, state) {
+    const ext = name.endsWith(".txt") ? "" : ".txt";
+    to_textfile(`${name}${ext}`, JSON.stringify(state));
+  }
+  /** With a filename, saves the session on the server under that name and returns the response.
+  Without one, creates a shareable link and renders it. */
+  async getSessionUrl(filename = "") {
+    const headers = await this.app.vocabApi.mayGetAuthHeaders(this.route);
+    const state = this.getState(this.app.getState(), true);
+    const { protocol, host, search, origin, href } = window.location;
+    state.embedder = { protocol, host, search, origin, href };
+    if (filename) {
+      state.__sessionFor__ = {
+        route: this.route,
+        filename,
+        dslabel: this.dslabel,
+        embedder: window.location.hostname
+      };
+    }
+    const res = await dofetch3("/massSession", {
+      headers,
+      method: "POST",
+      body: JSON.stringify(state)
+    });
+    if (filename) return res;
+    const div = this.dom.contentDiv;
+    if (res.error || !res.id) {
+      sayerror(div.append("div"), `Unable to create a session link: ${res.error || "missing session id"}`);
+      return;
+    }
+    const url = `${this.hostURL}/?mass-session-id=${encodeURIComponent(res.id)}&noheader=1`;
+    const linkDiv = div.append("div").style("margin", "10px");
+    const a = linkDiv.append("a").style("display", "none").attr("href", url).attr("target", "_blank").text(res.id);
+    linkDiv.append("button").style("cursor", "pointer").text("Open link").on("click", () => {
+      a.node().click();
+    });
+    linkDiv.append("button").style("cursor", "pointer").style("margin-left", "10px").text("Copy link").on("click", async (event) => {
+      await navigator.clipboard.writeText(url);
+      if (!this.dom?.copytip) return;
+      this.dom.copytip.clear().showunder(event.target);
+      this.dom.copytip.d.append("div").html("&#10003;");
+      clearTimeout(this.copyTipTimer);
+      this.copyTipTimer = setTimeout(() => this.dom?.copytip?.hide(), 1e3);
+    });
+    if (this.hostURL != window.location.origin) {
+      a.on("click", (event) => {
+        event.preventDefault();
+        parentCorsMessage({ state }, "noredirect");
+        return false;
+      });
+    }
+    linkDiv.append("div").html(`
+							<br>
+							<div style="font-size: 1em; opacity:.6">
+							<span>NOTES</span>
+							<ul>
+							<li>A recovered session may hide data or views to users that are not authorized to access the saved datasets or features.</li>
+							<li>This session will be saved for ${this.opts.massSessionDuration} days.</li>
+							</ul>
+							</div>`);
+  }
+  async delete() {
+    const t = await this.listSessions({
+      trClickHandler: function(event) {
+        const input = this.lastChild.querySelector("input");
+        const checked = event.target == input ? input.checked : !input.checked;
+        select_default(this).style("text-decoration", checked ? "line-through" : "");
+        if (event.target != input) input.checked = checked;
+        const checkedRows = t.table.node().querySelectorAll("input:checked");
+        submitBtn.property("disabled", checkedRows.length ? false : true);
+      }
+    });
+    t.headtr.append("th").text("Delete");
+    t.trs.each(function(d) {
+      select_default(this).append("td").style("text-align", "center").append("input").attr("type", "checkbox").attr("value", d.id);
+    });
+    const submitBtn = this.dom.contentDiv.append("div").style("margin-top", "10px").append("button").text("Delete selected sessions").property("disabled", true).on("click", async () => {
+      errorDiv.selectAll("*").remove();
+      const inputs = t.table.node().querySelectorAll("input");
+      const sessionIdsDeletedFromServer = [];
+      for (const input of inputs) {
+        if (select_default(input).property("checked")) {
+          const d = input.parentNode.parentNode.__data__;
+          if (d.loc == "browser") {
+            delete this.savedSessions[input.value];
+          } else if (d.loc == "server") {
+            sessionIdsDeletedFromServer.push(input.value);
+          } else throw `unknown cache location=${d.loc}`;
+        }
+      }
+      localStorage.setItem("savedMassSessions", JSON.stringify(this.savedSessions));
+      if (sessionIdsDeletedFromServer.length) {
+        submitBtn.property("disabled", true);
+        let error, failedIds;
+        try {
+          const headers = await this.app.vocabApi.mayGetAuthHeaders(this.route);
+          const errors = [];
+          failedIds = [];
+          for (const ids of getDeletionBatches(sessionIdsDeletedFromServer)) {
+            const body = { ids, route: this.route, dslabel: this.dslabel, embedder: window.location.hostname };
+            try {
+              const res = await dofetch3(`/massSession?`, { method: "DELETE", headers, body });
+              if (res.error) {
+                errors.push(res.error);
+                failedIds.push(...res.failedIds || ids);
+              }
+            } catch (e) {
+              errors.push(e.message || e);
+              failedIds.push(...ids);
+            }
+          }
+          if (errors.length) error = errors.join("; ");
+        } catch (e) {
+          error = e.message || e;
+          failedIds = sessionIdsDeletedFromServer;
+        }
+        const deletedIds = sessionIdsDeletedFromServer.filter((id2) => !failedIds?.includes(id2));
+        this.serverCachedSessions = this.serverCachedSessions?.filter((id2) => !deletedIds.includes(id2));
+        if (error) {
+          t.trs.filter((d) => d.loc == "browser" ? !this.savedSessions[d.id] : deletedIds.includes(d.id)).remove();
+          const checkedRows = t.table.node().querySelectorAll("input:checked");
+          submitBtn.property("disabled", !checkedRows.length);
+          sayerror(errorDiv, `Error deleting server session(s): ${error}`);
+          this.renderSessionOptions();
+          return;
+        }
+      }
+      this.renderSessionOptions();
+      this.clearContent();
+    });
+    const errorDiv = this.dom.contentDiv.append("div");
+  }
+  /** Show a message that fades out, then clear the content */
+  confirmAction(message) {
+    this.clearContent();
+    this.dom.contentDiv.append("div").text(message);
+    this.dom.contentDiv.transition().delay(3e3).duration(1e3).style("opacity", 0);
+    this.confirmationTimer = setTimeout(() => this.clearContent(), 4e3);
+  }
+};
+function getDeletionBatches(ids) {
+  const maxEncodedIdsLength = 1e3;
+  const batches = [];
+  let batch = [];
+  for (const id2 of ids) {
+    if (batch.length && encodeURIComponent(JSON.stringify([...batch, id2])).length > maxEncodedIdsLength) {
+      batches.push(batch);
+      batch = [];
+    }
+    batch.push(id2);
+  }
+  if (batch.length) batches.push(batch);
+  return batches;
+}
+async function preprocessState(state, app) {
+  delete state.termdbConfig;
+  if (state.plots) {
+    const promises = [];
+    for (const plot of state.plots) {
+      promises.push(
+        (async () => {
+          const _ = await importPlot(plot.chartType);
+          return await _.getPlotConfig(plot, app);
+        })()
+      );
+    }
+    try {
+      await Promise.all(promises);
+    } catch (e) {
+      console.error(e);
+      app.printError(e);
+    }
+  }
+}
+var userInit = getCompInit(MassUser);
+
+// mass/nav.ts
+var activeTabBgColor = "#ececec";
+var activeTabBgColorHover = "#e0e0e0";
+var activeTabTextColor = "black";
+var inactiveTabBgColorHover = "#fcfced";
+var inactiveTabTextColor = "gray";
+var instanceNum = 0;
+var idPrefix = "_MASS_AUTOID_" + Math.random().toString().slice(-6);
+var id = Number((+/* @__PURE__ */ new Date()).toString().slice(-8));
+var headtip = new Menu({ padding: "0px", offsetX: 0, offsetY: 0 });
+headtip.d.style("z-index", 5555);
+var aboutTab = { top: "ABOUT", mid: "", btm: "", subheader: "about" };
+var chartTab = { top: "CHARTS", mid: "NONE", btm: "", subheader: "charts" };
+var groupsTab = { top: "GROUPS", mid: "NONE", btm: "", subheader: "groups" };
+var filterTab = { top: "FILTER", mid: "NONE", btm: "", subheader: "filter" };
+var userTab = { top: "SESSION", mid: "", btm: "", subheader: "user" };
+function getUserTabMid(termdbConfig, activeCohort = -1) {
+  if (!termdbConfig?.requiredAuth?.length) return "";
+  const auth = termdbConfig.clientAuthResult;
+  const keys = termdbConfig.selectCohort?.values?.[activeCohort]?.keys || [];
+  const role = [auth?.role, ...keys.map((k) => auth?.[k]?.role)].find((r) => typeof r === "string" && r);
+  return role ? role.toUpperCase() : "";
+}
+function getId() {
+  return idPrefix + "_" + id++;
+}
+var TdbNav = class _TdbNav {
+  static {
+    this.type = "nav";
+  }
+  constructor(opts) {
+    this.type = _TdbNav.type;
+    this.instanceNum = instanceNum++;
+    this.tabs = [];
+    this.activeTab = 0;
+    this.activeCohort = 0;
+    this.samplecounts = {};
+    this.searching = false;
+    this.massSessionDuration = opts.massSessionDuration;
+    this.pkgver = opts.pkgver || null;
+    setInteractivity(this);
+    setRenderers(this);
+  }
+  async init(appState) {
+    this.cohortFilter = getFilterItemByTag(appState.termfilter.filter, "cohortFilter");
+    this.initUI(appState);
+    if (appState?.termdbConfig?.selectCohort) {
+      this.dom.tds.filter((d) => d.colNum === 0).style("display", "");
+      this.cohortNames = appState.termdbConfig.selectCohort.values.map((d) => d.keys.slice().sort().join(","));
+    }
+    this.components = await multiInit({
+      filter: filterRxCompInit({
+        app: this.app,
+        vocabApi: this.app.vocabApi,
+        holder: this.dom.subheader.filter.append("div").style("margin", "5px"),
+        hideLabel: this.opts.header_mode === "with_tabs",
+        emptyLabel: "+Add new filter",
+        callback: (filter) => {
+          this.app.dispatch({
+            type: "filter_replace",
+            filter
+          });
+        }
+      }),
+      charts: chartsInit({
+        app: this.app,
+        holder: this.dom.subheader.charts,
+        vocab: this.opts.vocab
+      }),
+      groups: groupsInit({
+        app: this.app,
+        holder: this.dom.subheader.groups,
+        vocab: this.opts.vocab
+      }),
+      recover: recoverInit({
+        app: this.app,
+        holder: this.dom.recoverDiv,
+        // TODO: ???? may limit the tracked state to only the filter, activeCohort ???
+        getState: (appState2) => appState2,
+        reactsTo: (action) => action.type != "plot_edit",
+        maxHistoryLen: 5
+      }),
+      about: aboutInit({
+        app: this.app,
+        subheader: this.dom.subheader.about,
+        instanceNum: this.instanceNum,
+        aboutOverrides: appState?.termdbConfig?.massNav?.tabs?.about || null,
+        selectCohort: appState?.termdbConfig?.selectCohort || null
+      }),
+      chat: chatInit({
+        app: this.app,
+        subheader: this.dom.subheader.chat
+      }),
+      user: userInit({
+        app: this.app,
+        subheader: this.dom.subheader.user,
+        massSessionDuration: this.opts.massSessionDuration,
+        sessionDaysLeft: this.app.opts.sessionDaysLeft ?? null,
+        sessionId: this.app.opts.sessionId || null
+      })
+    });
+  }
+  reactsTo(action) {
+    if (action.type.startsWith("filter")) return true;
+    if (action.type.startsWith("cohort")) return true;
+    if (action.type.startsWith("tab")) return true;
+    if (action.type == "plot_prep") return true;
+    if (action.type == "plot_create") return true;
+    if (action.type == "plot_delete") return true;
+    if (action.type == "app_refresh") return true;
+    if (action.type.endsWith("_customTerm")) return true;
+    if (action.type.endsWith("_group")) return true;
+  }
+  getState(appState) {
+    return {
+      searching: this.searching,
+      // for detection of internal state change
+      nav: appState.nav,
+      activeCohort: appState.activeCohort,
+      termdbConfig: appState.termdbConfig,
+      filter: appState.termfilter.filter,
+      plots: appState.plots,
+      groups: appState.groups
+    };
+  }
+  async main() {
+    this.dom.tabDiv.style("display", this.state.nav.header_mode === "with_tabs" ? "inline-block" : "none");
+    this.dom.tip.hide();
+    this.activeTab = this.state.nav.activeTab;
+    this.prevCohort = this.activeCohort;
+    this.activeCohort = +this.state.activeCohort;
+    this.filterUiRoot = getFilterItemByTag(this.state.filter, "filterUiRoot");
+    this.cohortFilter = getFilterItemByTag(this.state.filter, "cohortFilter");
+    if (this.cohortNames) {
+      this.activeCohortName = this.cohortNames[this.activeCohort];
+      if (this.activeCohort !== -1)
+        this.activeCohortLabel = this.state.termdbConfig.selectCohort.values[this.activeCohort].shortLabel;
+    }
+    this.filterJSON = JSON.stringify(this.state.filter);
+    this.cohortsData = await this.app.vocabApi.getCohortsData();
+    if (this.state.nav.header_mode === "with_tabs") {
+      if (!(this.activeCohort in this.samplecounts)) {
+        this.samplecounts[this.activeCohort] = await this.app.vocabApi.getCohortSampleCount(this.activeCohortName);
+      }
+      if (!(this.filterJSON in this.samplecounts)) {
+        if (!this.filterUiRoot || !this.filterUiRoot.lst.length) {
+          this.samplecounts[this.filterJSON] = this.samplecounts[this.activeCohort];
+        } else {
+          const n = await this.app.vocabApi.getFilteredSampleCount(this.filterJSON);
+          this.samplecounts[this.filterJSON] = n;
+        }
+      }
+    }
+    this.updateUI();
+  }
+};
+var navInit = getCompInit(TdbNav);
+function setRenderers(self) {
+  self.initUI = (appState) => {
+    const verifiedToken = self.app.vocabApi.verifiedToken;
+    const invalidTokenErrorHandling = appState.termdbConfig.invalidTokenErrorHandling;
+    if (!verifiedToken && invalidTokenErrorHandling?.affectedCharts?.includes("*"))
+      throw new Error(appState.termdbConfig.invalidTokenErrorHandling.errorMessage);
+    const header = self.opts.holder.append("div").style("white-space", "nowrap").style("display", "flex").style("align-items", "stretch");
+    const massNav = appState.termdbConfig?.massNav || {};
+    const titleDiv = header.append("div").style("order", "2").style("align-self", "flex-start").style("font-size", "1.1em").style("margin", "50px 10px 0 0").text(massNav?.title?.text);
+    const tabDiv = header.append("div").style("display", "none").style("vertical-align", "bottom");
+    const controlsDiv = header.append("div").style("order", "1").style("margin", "10px 10px 10px auto").style("text-align", "right");
+    if (self.opts.header_mode === "only_buttons") {
+      tabDiv.style("display", "none");
+      titleDiv.style("display", "none");
+      controlsDiv.style("display", "none");
+    }
+    self.opts.holder.attr("class", "sjpp-nav");
+    self.dom = {
+      holder: self.opts.holder,
+      header,
+      tabDiv,
+      controlsDiv,
+      searchDiv: controlsDiv.append("div").style("margin", "10px"),
+      recoverDiv: controlsDiv.append("div").style("display", "inline-block"),
+      pdfDiv: controlsDiv.append("div").style("display", "inline-block").style("padding", "4px").style("vertical-align", "middle"),
+      deleteAllDiv: controlsDiv.append("div").style("display", "inline-block").style("padding", "4px").style("vertical-align", "middle"),
+      helpDiv: controlsDiv.append("div").style("display", "none"),
+      subheaderDiv: self.opts.holder.append("div").style("display", "block").style("border-bottom", "1px solid #000"),
+      messageDiv: self.opts.holder.append("div").style("margin", "30px").style("display", "none"),
+      titleDiv,
+      tip: new Menu({ padding: "5px" })
+    };
+    icons["trash"](self.dom.deleteAllDiv, {
+      handler: self.deletePlots,
+      title: "Delete all plots. To revert, click Undo button"
+    });
+    icons["pdf"](self.dom.pdfDiv, {
+      handler: self.opts.downloadPlots,
+      title: "Generate a PDF of all the plots opened"
+    });
+    if (self.opts.header_mode === "with_cohortHtmlSelect") {
+      self.dom.cohortStandaloneDiv = header.append("div").style("display", "inline-block").style("margin", "10px").style("vertical-align", "top");
+      self.dom.cohortStandaloneDiv.append("label").html("Cohort: ");
+      self.dom.cohortSelect = self.dom.cohortStandaloneDiv.append("select").on("change", async function() {
+        self.app.dispatch({ type: "cohort_set", activeCohort: +this.value });
+      });
+      self.dom.cohortSelect.selectAll("option").data(appState.termdbConfig.selectCohort.values).enter().append("option").attr("value", (d, i) => i).property("selected", (d, i) => i === appState.activeCohort).html((d) => d.shortLabel);
+    }
+    self.dom.subheader = Object.freeze({
+      // For either the COHORT or ABOUT tab
+      about: self.dom.subheaderDiv.append("div").attr("data-testid", "sjpp-mass-nav-subheader-about").style("display", "none"),
+      search: self.dom.subheaderDiv.append("div").attr("data-testid", "sjpp-mass-nav-subheader-search").style("display", "none"),
+      groups: self.dom.subheaderDiv.append("div").attr("data-testid", "sjpp-mass-nav-subheader-groups").style("display", "none"),
+      charts: self.dom.subheaderDiv.append("div").attr("data-testid", "sjpp-mass-nav-subheader-charts").style("display", "none"),
+      filter: self.dom.subheaderDiv.append("div").attr("data-testid", "sjpp-mass-nav-subheader-filter").style("display", "none"),
+      chat: self.dom.subheaderDiv.append("div").attr("data-testid", "sjpp-mass-nav-subheader-chat").style("display", "none"),
+      user: self.dom.subheaderDiv.append("div").attr("data-testid", "sjpp-mass-nav-subheader-user").style("display", "none")
+      // cart: self.dom.subheaderDiv.append('div').style('display', 'none').html('<br/>Cart feature under construction - work in progress<br/>&nbsp;<br/>'),
+    });
+    if (!massNav.tabs?.about?.hide) {
+      self.tabs.push(aboutTab);
+      const override = Object.assign({}, massNav.tabs?.about);
+      if (appState.termdbConfig?.selectCohort) {
+        if (!override.top) override.top = "COHORT";
+      } else {
+        if (!override.mid) override.mid = self.pickDatasetLabel(appState);
+      }
+      Object.assign(aboutTab, override);
+    }
+    if (!massNav.tabs?.charts?.hide) {
+      self.tabs.push(chartTab);
+      Object.assign(chartTab, massNav.tabs?.charts);
+    }
+    if (!massNav.tabs?.groups?.hide) {
+      self.tabs.push(groupsTab);
+      Object.assign(groupsTab, massNav.tabs?.groups);
+    }
+    if (!massNav.tabs?.filter?.hide) {
+      self.tabs.push(filterTab);
+      Object.assign(filterTab, massNav.tabs?.filter);
+    }
+    if (!massNav.tabs?.chat?.hide) {
+      if (appState.termdbConfig?.queries?.chat) {
+        const chatTab = { top: "CHAT", mid: "", btm: "", subheader: "chat" };
+        Object.assign(chatTab, massNav.tabs?.chat);
+        chatTab.top = "CHAT";
+        self.tabs.push(chatTab);
+      } else {
+        const searchTab = { top: "SEARCH", mid: "", btm: "", subheader: "chat" };
+        Object.assign(searchTab, massNav.tabs?.chat);
+        searchTab.top = "SEARCH";
+        self.tabs.push(searchTab);
+      }
+    }
+    if (!massNav.tabs?.user?.hide) {
+      const override = Object.assign({}, massNav.tabs?.user);
+      if (!override.mid) override.mid = getUserTabMid(appState.termdbConfig, appState.activeCohort);
+      self.tabs.push(Object.assign({}, userTab, override));
+    }
+    const table = self.dom.tabDiv.append("table").attr("data-testid", "sjpp-nav-tabs-table").style("border-collapse", "collapse").style("height", "100%");
+    table.selectAll("tr").data(["top", "mid", "btm"]).enter().append("tr").attr("class", (d, i) => `sjpp-nav-tabs-row-${i}`).style("font-size", (d, i) => i == 1 ? "20px" : "12px").selectAll("td").data(
+      (key, i) => self.tabs.map((row, colNum) => {
+        return {
+          rowNum: i,
+          key,
+          colNum,
+          label: row[key],
+          subheader: row.subheader,
+          disabled: row.disabled,
+          disabledMessage: row.disabledMessage
+        };
+      })
+    ).enter().append("td").attr("class", (d) => `sjpp-nav-tab-col-${d.colNum}`).attr("data-testid", (d) => `sjpp-nav-tab-col-${d.label}`).style("display", "none").style("width", "100px").style("padding", (d) => d.rowNum === 0 ? "12px 12px 3px 12px" : "3px 12px").style("text-align", "center").style("border-left", "1px solid #ccc").style("border-right", "1px solid #ccc").style("color", "#aaa").style("opacity", (d) => d.disabled ? 0.5 : 1).style("cursor", (d) => d.disabled ? "not-allowed" : "pointer").attr("title", (d) => d.disabledMessage || "").html((d) => d.label).on("click", (event, d) => {
+      self.setTab(event, d);
+    }).on("mouseover", (event, d) => {
+      self.mouseover(event, d);
+    }).on("mouseout", (event, d) => {
+      self.mouseout(d);
+    });
+    self.dom.trs = table.selectAll("tr");
+    self.dom.tds = table.selectAll("td");
+    self.subheaderKeys = self.tabs.map((d) => d.subheader);
+  };
+  self.deletePlots = () => {
+    const state = self.app.getState();
+    const subactions = [];
+    for (const plot of state.plots) subactions.push({ type: "plot_delete", id: plot.id });
+    self.app.dispatch({ type: "app_refresh", subactions });
+  };
+  self.updateUI = async () => {
+    if (!self.dom.subheaderDiv) return;
+    const isUserTab = self.tabs[self.activeTab]?.subheader === "user";
+    if (self.activeTab && !isUserTab && self.state.termdbConfig.selectCohort && self.activeCohort == -1) {
+      self.dom.subheaderDiv.style("display", "none");
+      self.dom.messageDiv.selectAll("text").remove();
+      self.dom.messageDiv.style("display", "").text('No cohort selected. Please select a cohort in the "COHORT" tab.');
+    } else {
+      if (self.dom.subheaderDiv) self.dom.subheaderDiv.style("display", self.activeTab != -1 ? "block" : "none");
+      if (self.dom.messageDiv) self.dom.messageDiv.style("display", "none");
+    }
+    const selectCohort = self.state.termdbConfig.selectCohort;
+    const massNav = self.state.termdbConfig.massNav;
+    self.dom.searchDiv.style("display", selectCohort && self.activeCohort == -1 ? "none" : "inline-block");
+    self.dom.header.style("border-bottom", self.state.nav.header_mode === "with_tabs" ? "1px solid #000" : "");
+    self.dom.tds.style("display", "").style("color", (d) => d.colNum == self.activeTab ? activeTabTextColor : inactiveTabTextColor).style(
+      "background-color",
+      (d) => d.colNum == self.activeTab && self.dom.subheaderDiv.style("display") != "none" ? self.state.termdbConfig.massNav?.activeColor || activeTabBgColor : "transparent"
+    ).html(function(d) {
+      if (d.key == "top") return this.innerHTML;
+      if (d.subheader == "groups") {
+        if (d.key == "mid") return self.state.groups.length || "NONE";
+        return "";
+      }
+      if (d.subheader === "charts") {
+        const n = self.state.plots.filter((p) => !p.parentId).length;
+        if (d.key == "mid") return !n ? "NONE" : n;
+        else return "";
+      } else if (d.subheader === "about") {
+        if (self.activeCohort != -1 && self.activeCohort in self.samplecounts) {
+          const aboutMap = {
+            top: this.innerHTML,
+            mid: self.activeCohortLabel,
+            btm: self.samplecounts[self.activeCohort]
+          };
+          return aboutMap[d.key] || "";
+        } else if (!selectCohort) {
+          const aboutMap = {
+            top: massNav?.tabs?.about?.top || "ABOUT",
+            mid: massNav?.tabs?.about?.mid || this.innerHTML,
+            btm: massNav?.tabs?.about?.btm || self.samplecounts[self.activeCohort]
+          };
+          return aboutMap[d.key] || "";
+        } else {
+          return d.key === "mid" ? "NONE" : this.innerHTML;
+        }
+      } else if (d.subheader === "filter") {
+        const filter = self.filterUiRoot ? self.filterUiRoot : { lst: [] };
+        if (filter.lst.length === 0) {
+          return d.key === "mid" ? "NONE" : "";
+        } else {
+          const n = self.samplecounts[self.filterJSON] != void 0 ? "" + self.samplecounts[self.filterJSON] : "";
+          return d.key === "mid" ? filter.lst.length : n;
+        }
+      } else if (d.subheader === "user" && d.key == "btm") {
+        return getDaysLeft(self.app.opts.sessionDaysLeft)?.text || "&nbsp;";
+      } else if (d.subheader === "user" && d.key == "mid" && !massNav?.tabs?.user?.mid) {
+        return getUserTabMid(self.state.termdbConfig, self.activeCohort);
+      } else {
+        return d.key === "mid" ? this.innerHTML : "&nbsp;";
+      }
+    });
+    for (const key in self.dom.subheader) {
+      self.dom.subheader[key].style(
+        "display",
+        self.activeTab == -1 ? "none" : self.tabs[self.activeTab].subheader === key ? "block" : "none"
+      );
+    }
+    if (self.opts.header_mode === "with_cohortHtmlSelect") {
+      self.dom.cohortSelect.selectAll("option").property("value", self.activeCohort);
+    }
+  };
+}
+function setInteractivity(self) {
+  self.setTab = async (event, d) => {
+    if (d.disabled) return;
+    if (d.colNum === self.activeTab && !self.searching) {
+      if (self.activeTab == 0) return;
+      self.prevCohort = self.activeCohort;
+      await self.updateUI();
+      self.app.dispatch({ type: "tab_set", activeTab: -1 });
+      return;
+    }
+    self.activeTab = d.colNum;
+    self.searching = false;
+    self.app.dispatch({ type: "tab_set", activeTab: self.activeTab });
+    const chartsIdx = self.subheaderKeys.indexOf("charts");
+    if (self.activeTab == chartsIdx && self.activeCohort != -1 && !self.state.plots.length) {
+      const defaultChartType = self.state.termdbConfig.defaultChartType || "dictionary";
+      self.app.dispatch({
+        type: "plot_create",
+        id: getId(),
+        config: { chartType: defaultChartType }
+      });
+    }
+  };
+  self.mouseover = (event, d) => {
+    const defaultActiveColor = self.state.termdbConfig.massNav?.activeColor || activeTabBgColor;
+    if (d.subheader == "user" && d.key == "btm") self.components.user?.showDaysLeftTip(event.currentTarget);
+    self.dom.tds.style("background-color", (t) => {
+      if (t.colNum === d.colNum)
+        return self.activeTab == t.colNum ? self.state.termdbConfig.massNav?.activeColorHover || activeTabBgColorHover : inactiveTabBgColorHover;
+      return self.activeTab == t.colNum ? defaultActiveColor : "transparent";
+    });
+  };
+  self.mouseout = (d) => {
+    if (d.subheader == "user" && d.key == "btm") self.components.user?.hideDaysLeftTip();
+    const defaultActiveColor = self.state.termdbConfig.massNav?.activeColor || activeTabBgColor;
+    self.dom.tds.style("background-color", (t) => self.activeTab == t.colNum ? defaultActiveColor : "transparent");
+  };
+  self.pickDatasetLabel = (appState) => {
+    const dslabel = appState.vocab.dslabel.toUpperCase();
+    return dslabel.length > 10 ? `${dslabel.slice(0, 10)}...` : dslabel;
+  };
+}
+
+export {
+  getId,
+  navInit
+};
+//# sourceMappingURL=chunk-VPRP24DY.js.map