igv 3.1.2 → 3.1.4

package/dist/igv.esm.js

@@ -19431,7 +19431,7 @@ function doPath(ctx, x, y) {
     ctx.closePath();
 }
 
-/*! @license DOMPurify 3.2.3 | (c) Cure53 and other contributors | Released under the Apache license 2.0 and Mozilla Public License 2.0 | github.com/cure53/DOMPurify/blob/3.2.3/LICENSE */
+/*! @license DOMPurify 3.2.4 | (c) Cure53 and other contributors | Released under the Apache license 2.0 and Mozilla Public License 2.0 | github.com/cure53/DOMPurify/blob/3.2.4/LICENSE */
 
 const {
   entries,
@@ -19470,8 +19470,10 @@ if (!construct) {
   };
 }
 const arrayForEach = unapply(Array.prototype.forEach);
+const arrayLastIndexOf = unapply(Array.prototype.lastIndexOf);
 const arrayPop = unapply(Array.prototype.pop);
 const arrayPush = unapply(Array.prototype.push);
+const arraySplice = unapply(Array.prototype.splice);
 const stringToLowerCase = unapply(String.prototype.toLowerCase);
 const stringToString = unapply(String.prototype.toString);
 const stringMatch = unapply(String.prototype.match);
@@ -19627,7 +19629,7 @@ const xml = freeze(['xlink:href', 'xml:id', 'xlink:title', 'xml:space', 'xmlns:x
 // eslint-disable-next-line unicorn/better-regex
 const MUSTACHE_EXPR = seal(/\{\{[\w\W]*|[\w\W]*\}\}/gm); // Specify template detection regex for SAFE_FOR_TEMPLATES mode
 const ERB_EXPR = seal(/<%[\w\W]*|[\w\W]*%>/gm);
-const TMPLIT_EXPR = seal(/\$\{[\w\W]*}/gm); // eslint-disable-line unicorn/better-regex
+const TMPLIT_EXPR = seal(/\$\{[\w\W]*/gm); // eslint-disable-line unicorn/better-regex
 const DATA_ATTR = seal(/^data-[\-\w.\u00B7-\uFFFF]+$/); // eslint-disable-line no-useless-escape
 const ARIA_ATTR = seal(/^aria-[\-\w]+$/); // eslint-disable-line no-useless-escape
 const IS_ALLOWED_URI = seal(/^(?:(?:(?:f|ht)tps?|mailto|tel|callto|sms|cid|xmpp):|[^a-z]|[a-z+.\-]+(?:[^a-z+.\-:]|$))/i // eslint-disable-line no-useless-escape
@@ -19727,9 +19729,9 @@ const _createHooksMap = function _createHooksMap() {
 function createDOMPurify() {
   let window = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : getGlobal();
   const DOMPurify = root => createDOMPurify(root);
-  DOMPurify.version = '3.2.3';
+  DOMPurify.version = '3.2.4';
   DOMPurify.removed = [];
-  if (!window || !window.document || window.document.nodeType !== NODE_TYPE.document) {
+  if (!window || !window.document || window.document.nodeType !== NODE_TYPE.document || !window.Element) {
     // Not running in a browser, provide a factory function
     // so that you can pass your own Window
     DOMPurify.isSupported = false;
@@ -20748,7 +20750,11 @@ function createDOMPurify() {
     }
     arrayPush(hooks[entryPoint], hookFunction);
   };
-  DOMPurify.removeHook = function (entryPoint) {
+  DOMPurify.removeHook = function (entryPoint, hookFunction) {
+    if (hookFunction !== undefined) {
+      const index = arrayLastIndexOf(hooks[entryPoint], hookFunction);
+      return index === -1 ? undefined : arraySplice(hooks[entryPoint], index, 1)[0];
+    }
     return arrayPop(hooks[entryPoint]);
   };
   DOMPurify.removeHooks = function (entryPoint) {
@@ -24664,6 +24670,533 @@ function stripQuotes$1(value) {
     return value
 }
 
+/**
+ * Some interpretations of the sequence ontology needed to assemble GFF transcripts.
+ *
+ */
+
+const transcriptTypes = new Set(['transcript', 'primary_transcript', 'processed_transcript', 'mRNA', 'mrna',
+    'lnc_RNA', 'miRNA', 'ncRNA', 'rRNA', 'scRNA', 'snRNA', 'snoRNA', 'tRNA']);
+const cdsTypes = new Set(['CDS', 'cds']);
+const codonTypes = new Set(['start_codon', 'stop_codon']);
+const utrTypes = new Set(['5UTR', '3UTR', 'UTR', 'five_prime_UTR', 'three_prime_UTR', "3'-UTR", "5'-UTR"]);
+const exonTypes = new Set(['exon', 'coding-exon']);
+
+const transcriptPartTypes = new Set();
+for (let cltn of [cdsTypes, codonTypes, utrTypes, exonTypes]) {
+    for (let t of cltn) {
+        transcriptPartTypes.add(t);
+    }
+}
+
+function isExon(type) {
+    return exonTypes.has(type)
+}
+
+function isIntron(type) {
+    return type.includes("intron")
+}
+
+function isCoding(type) {
+    return cdsTypes.has(type) || codonTypes.has(type)
+}
+
+function isUTR(type) {
+    return utrTypes.has(type)
+}
+
+function isTranscript(type) {
+    return transcriptTypes.has(type) || type.endsWith("RNA") || type.endsWith("transcript")
+}
+
+function isTranscriptPart(type) {
+    return transcriptPartTypes.has(type) || type.endsWith("RNA") || isIntron(type)
+}
+
+const filterPopupProperties = new Set(["id", "parent", "name"]);
+
+class GFFFeature {
+
+    constructor(properties) {
+
+        Object.assign(this, properties);
+
+        if (properties.phase !== undefined && "." !== properties.phase) {
+            this.readingFrame = (3 - parseInt(properties.phase)) % 3;
+        }
+
+    }
+
+
+    popupData(genomicLocation) {
+
+        const pd = this.geneObject ? this.geneObject.popupData() : [];
+
+        if (this.geneObject) {
+            pd.push('<hr/>');
+        }
+
+        if (this.name) {
+            pd.push({name: 'Name', value: this.name});
+        }
+
+        pd.push({name: 'Type', value: this.type});
+        pd.push({name: 'Source', value: this.source});
+        if (this.score !== undefined) {
+            pd.push({name: 'Score', value: this.score});
+        }
+        pd.push({name: 'Phase', value: this.phase});
+
+        if (this.attributeString) {
+            const atts = parseAttributeString(this.attributeString, this.delim);
+            for (let [key, value] of atts) {
+                if (value !== undefined && value.length > 0 && !filterPopupProperties.has(key.toLowerCase())) {
+                    pd.push({name: key + ":", value: value});
+                }
+            }
+        }
+        pd.push({
+            name: 'Location',
+            value: `${this.chr}:${numberFormatter$1(this.start + 1)}-${numberFormatter$1(this.end)}`
+        });
+        return pd
+    }
+
+    getAttributeValue(attributeName) {
+        if (this.hasOwnProperty(attributeName)) {
+            return this[attributeName]
+        } else {
+            // TODO -- fetch from attribute string and cache
+            if (!this._attributeCache) {
+                this._attributeCache = new Map();
+            }
+            if (this._attributeCache.has(attributeName)) {
+                return this._attributeCache.get(attributeName)
+            } else {
+                const atts = parseAttributeString(this.attributeString, this.delim);
+                let v;
+                for (let [key, value] of atts) {
+                    if (key === attributeName) {
+                        v = value;
+                        break
+                    }
+                }
+                this._attributeCache.set(attributeName, v);
+                return v
+            }
+        }
+    }
+}
+
+class GFFTranscript extends GFFFeature {
+
+    constructor(feature) {
+        super(feature);
+        this.exons = [];
+        this.parts = [];
+    }
+
+    addExon(feature) {
+
+        this.exons.push(feature);
+
+        // Expand feature --  for transcripts not explicitly represented in the file (gtf)
+        this.start = Math.min(this.start, feature.start);
+        this.end = Math.max(this.end, feature.end);
+    }
+
+    addPart(feature) {
+        this.parts.push(feature);
+    }
+
+    assembleParts() {
+
+        if (this.parts.length === 0) return
+
+        this.parts.sort(function (a, b) {
+            return a.start - b.start
+        });
+
+        // Create exons, if neccessary
+        let lastStart = this.parts[0].start;
+        let lastEnd = this.parts[0].end;
+        for (let i = 1; i < this.parts.length; i++) {
+            const part = this.parts[i];
+            if (isIntron(part.type)) {
+                continue
+            }
+            if (part.start <= lastEnd) {
+                lastEnd = Math.max(lastEnd, part.end);
+            } else {
+                let exon = this.findExonContaining({start: lastStart, end: lastEnd});
+                if (!exon) {
+                    this.exons.push({start: lastStart, end: lastEnd, psuedo: true});
+                }
+                lastStart = part.start;
+                lastEnd = part.end;
+            }
+        }
+        let exon = this.findExonContaining({start: lastStart, end: lastEnd});
+        if (!exon) {
+            this.exons.push({start: lastStart, end: lastEnd, psuedo: true});
+            this.start = Math.min(this.start, lastStart);
+            this.end = Math.max(this.end, lastEnd);
+        }
+
+
+        for (let part of this.parts) {
+            const type = part.type;
+            if (isCoding(type)) {
+                this.addCDS(part);
+            } else if (isUTR(type)) {
+                this.addUTR(part);
+            }
+        }
+    }
+
+    findExonContaining({start, end}) {
+        for (let exon of this.exons) {
+            if (exon.end >= end && exon.start <= start) {
+                return exon
+            }
+        }
+        return undefined
+    }
+
+    addCDS(cds) {
+
+        let exon;
+        const exons = this.exons;
+
+        for (let e of exons) {
+            if (e.start <= cds.start && e.end >= cds.end) {
+                exon = e;
+                break
+            }
+        }
+
+        if (exon) {
+            exon.cdStart = exon.cdStart ? Math.min(cds.start, exon.cdStart) : cds.start;
+            exon.cdEnd = exon.cdEnd ? Math.max(cds.end, exon.cdEnd) : cds.end;
+            exon.readingFrame = cds.readingFrame;
+            // TODO -- merge attributes?
+        } else {
+            // cds.cdStart = cds.start
+            // cds.cdEnd = cds.end
+            // exons.push(cds)
+            console.error("No exon found spanning " + cds.start + "-" + cds.end);
+        }
+
+        // Expand feature --  for transcripts not explicitly represented in the file (gtf files)
+        // this.start = Math.min(this.start, cds.start);
+        // this.end = Math.max(this.end, cds.end);
+
+        this.cdStart = this.cdStart ? Math.min(cds.start, this.cdStart) : cds.start;
+        this.cdEnd = this.cdEnd ? Math.max(cds.end, this.cdEnd) : cds.end;
+    }
+
+    addUTR(utr) {
+
+        let exon;
+        const exons = this.exons;
+
+        // Find exon containing CDS
+        for (let i = 0; i < exons.length; i++) {
+            if (exons[i].start <= utr.start && exons[i].end >= utr.end) {
+                exon = exons[i];
+                break
+            }
+        }
+
+        if (exon) {
+            if (utr.start === exon.start && utr.end === exon.end) {
+                exon.utr = true;
+            } else {
+                if (utr.end < exon.end) {
+                    exon.cdStart = utr.end;
+                }
+                if (utr.start > exon.start) {
+                    exon.cdEnd = utr.start;
+                }
+            }
+
+        } else {
+            // utr.utr = true
+            // exons.push(utr)
+            console.error("No exon found spanning " + cds.start + "-" + cds.end);
+        }
+
+        // Expand feature --  for transcripts not explicitly represented in the file
+        // this.start = Math.min(this.start, utr.start);
+        // this.end = Math.max(this.end, utr.end);
+
+    }
+
+    finish() {
+
+        this.assembleParts();
+
+        var cdStart = this.cdStart;
+        var cdEnd = this.cdEnd;
+
+        this.exons.sort(function (a, b) {
+            return a.start - b.start
+        });
+
+        // Search for UTR exons that were not explicitly tagged
+        if (cdStart) {
+            this.exons.forEach(function (exon) {
+                if (exon.end < cdStart || exon.start > cdEnd) exon.utr = true;
+            });
+        }
+    }
+
+    popupData(genomicLocation) {
+
+        const pd = super.popupData(genomicLocation);
+
+        // If clicked over an exon add its attributes
+        for (let exon of this.exons) {
+            if (exon.pseudo) continue  // An implicit exon
+            if (genomicLocation >= exon.start && genomicLocation < exon.end && typeof exon.popupData === 'function') {
+                pd.push('<hr/>');
+                const exonData = exon.popupData(genomicLocation);
+                for (let att of exonData) {
+                    pd.push(att);
+                }
+            }
+        }
+
+        for (let part of this.parts) {
+            if (genomicLocation >= part.start && genomicLocation < part.end && typeof part.popupData === 'function') {
+                pd.push('<hr/>');
+                const partData = part.popupData(genomicLocation);
+                for (let att of partData) {
+                    pd.push(att);
+                }
+            }
+        }
+
+
+        return pd
+    }
+}
+
+class GFFHelper {
+
+    static gffNameFields = new Set(["Name", "transcript_id", "gene_name", "gene", "gene_id", "alias", "locus", "name" ])
+    constructor(options) {
+        this.format = options.format;
+        this.nameField = options.nameField;
+        this.filterTypes = options.filterTypes === undefined ?
+            new Set(['chromosome']) :
+            new Set(options.filterTypes);
+    }
+
+    combineFeatures(features, genomicInterval) {
+
+        let combinedFeatures;
+
+        const filterTypes = this.filterTypes;
+        features = features.filter(f => filterTypes === undefined || !filterTypes.has(f.type));
+
+        if ("gff3" === this.format) {
+            const tmp = this.combineFeaturesById(features);
+            combinedFeatures = this.combineFeaturesByType(tmp);
+        } else {
+            combinedFeatures = this.combineFeaturesByType(features);
+        }
+
+        this.numberExons(combinedFeatures, genomicInterval);
+        this.nameFeatures(combinedFeatures);
+        return combinedFeatures
+    }
+
+    /**
+     * Combine multiple non-transcript model features with the same ID on the same chromosome into a single feature.
+     * Features that are part of the transcript model (e.g. exon, mRNA, etc) are combined later.
+     *
+     * @param features
+     * @returns {[]}
+     */
+    combineFeaturesById(features) {
+
+        const chrIdMap = new Map();
+        const combinedFeatures = [];
+
+        for (let f of features) {
+            if (isTranscriptPart(f.type) || isTranscript(f.type) || !f.id) {
+                combinedFeatures.push(f);
+            } else {
+                let idMap = chrIdMap.get(f.chr);
+                if (!idMap) {
+                    idMap = new Map();
+                    chrIdMap.set(f.chr, idMap);
+                }
+
+                let featureArray = idMap.get(f.id);
+                if (featureArray) {
+                    featureArray.push(f);
+                } else {
+                    idMap.set(f.id, [f]);
+                }
+            }
+        }
+
+        for (let idMap of chrIdMap.values()) {
+            for (let featureArray of idMap.values()) {
+                if (featureArray.length > 1) {
+                    // Use the first feature as prototypical (for column 9 attributes), and adjust start/end
+                    // Parts are represented as "exons", as that is how they are presented visually
+                    const cf = featureArray[0];
+                    cf.exons = [];
+                    for (let f of featureArray) {
+                        cf.start = Math.min(cf.start, f.start);
+                        cf.end = Math.max(cf.end, f.end);
+                        cf.exons.push({
+                            start: f.start,
+                            end: f.end
+                        });
+                    }
+                    combinedFeatures.push(cf);
+                } else {
+                    combinedFeatures.push(featureArray[0]);
+                }
+            }
+        }
+
+        return combinedFeatures
+    }
+
+    combineFeaturesByType(features) {
+
+        // Build dictionary of genes
+        const genes = features.filter(f => "gene" === f.type || f.type.endsWith("_gene"));
+        const geneMap = Object.create(null);
+        for (let g of genes) {
+            geneMap[g.id] = g;
+        }
+
+        // 1. Build dictionary of transcripts
+        const transcripts = Object.create(null);
+        const combinedFeatures = [];
+        const consumedFeatures = new Set();
+        const filterTypes = this.filterTypes;
+
+        features = features.filter(f => filterTypes === undefined || !filterTypes.has(f.type));
+
+        for (let f of features) {
+            if (isTranscript(f.type)) {
+                const transcriptId = f.id; // getAttribute(f.attributeString, "transcript_id", /\s+/);
+                if (undefined !== transcriptId) {
+                    const gffTranscript = new GFFTranscript(f);
+                    transcripts[transcriptId] = gffTranscript;
+                    combinedFeatures.push(gffTranscript);
+                    consumedFeatures.add(f);
+                    const g = geneMap[f.parent];
+                    if (g) {
+                        gffTranscript.geneObject = g;
+                        consumedFeatures.add(g);
+                    }
+                }
+            }
+        }
+
+        // Add exons and transcript parts
+        for (let f of features) {
+            if (isTranscriptPart(f.type)) {
+                const parents = getParents(f);
+                if (parents) {
+                    for (let id of parents) {
+
+                        let transcript = transcripts[id];
+                        if (!transcript && this.format === "gtf") {
+                            // GTF does not require explicit a transcript or mRNA record, start one with this feature.
+                            const psuedoTranscript = Object.assign({}, f);
+                            psuedoTranscript.type = "transcript";
+                            transcript = new GFFTranscript(psuedoTranscript);
+                            transcripts[id] = transcript;
+                            combinedFeatures.push(transcript);
+                        }
+                        if (transcript !== undefined) {
+
+                            if (isExon(f.type)) {
+                                if (parents.length > 1) {
+                                    // Multiple parents, this is unusual.  Make a copy as exon can be modified
+                                    // differently by CDS, etc, for each parent
+                                    const e2 = new GFFFeature(f);
+                                    transcript.addExon(e2);
+                                } else {
+                                    transcript.addExon(f);
+                                }
+                            } else {
+                                transcript.addPart(f);
+                            }
+                            consumedFeatures.add(f);
+                        }
+                    }
+                }
+            }
+        }
+
+        // Finish transcripts
+        combinedFeatures.forEach(function (f) {
+            if (typeof f.finish === "function") {
+                f.finish();
+            }
+        });
+
+        // Add other features
+        const others = features.filter(f => !consumedFeatures.has(f));
+        for (let f of others) {
+            combinedFeatures.push(f);
+        }
+
+        return combinedFeatures
+
+        function getParents(f) {
+            if (f.parent && f.parent.trim() !== "") {
+                return f.parent.trim().split(",")
+            } else {
+                return null
+            }
+        }
+    }
+
+    numberExons(features, genomicInterval) {
+
+        for (let f of features) {
+            if (f.exons &&
+                (!genomicInterval ||
+                    (f.end <= genomicInterval.end && f.start > genomicInterval.start))) {
+                for (let i = 0; i < f.exons.length; i++) {
+                    const exon = f.exons[i];
+                    exon.number = f.strand === "-" ? f.exons.length - i : i + 1;
+                }
+            }
+        }
+    }
+
+    nameFeatures(features) {
+        // Find name (label) property
+        for (let f of features) {
+            if(typeof f.getAttributeValue === 'function') {
+                if (this.nameField) {
+                    f.name = f.getAttributeValue(this.nameField);
+                } else {
+                    for (let nameField of GFFHelper.gffNameFields) {
+                        const v = f.getAttributeValue(nameField);
+                        if (v) {
+                            f.name = v;
+                            break
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
 /**
  * Decode the UCSC bed format.  Only the first 3 columns (chr, start, end) are required.   The remaining columns
  * must follow standard bed order, but we will tolerate deviations after column 3.
@@ -24676,7 +25209,7 @@ function decodeBed(tokens, header, maxColumnCount = Number.MAX_SAFE_INTEGER) {
 
     if (tokens.length < 3) return undefined
 
-    header && header.gffTags;
+    const gffTags = header && header.gffTags;
 
     const chr = tokens[0];
     const start = parseInt(tokens[1]);
@@ -24696,12 +25229,16 @@ function decodeBed(tokens, header, maxColumnCount = Number.MAX_SAFE_INTEGER) {
                 feature.attributes = {};
                 for (let kv of attributeKVs) {
                     feature.attributes[kv[0]] = kv[1];
-                    if (header.nameField != undefined && kv[0] === header.nameField) {
-                        feature.name = kv[1];
+                    if(gffTags) {
+                        if (header.nameField != undefined && kv[0] === header.nameField) {
+                            feature.name = kv[1];
+                        } else if (!feature.name && GFFHelper.gffNameFields.has(kv[0])) {
+                            feature.name = kv[1];
+                        }
                     }
                 }
             }
-            if (!feature.name) {
+            if (!feature.name && !gffTags) {
                 feature.name = tokens[3] === '.' ? '' : tokens[3];
             }
         }
@@ -25120,505 +25657,193 @@ function decodeBedGraph(tokens, header) {
         if (colorColumn && colorColumn < tokens.length) {
             feature.color = IGVColor.createColorString(tokens[colorColumn]);
         }
-    }
-
-    return feature
-}
-
-function decodeWig(tokens, header) {
-
-    const wig = header.wig;
-
-    if (wig && wig.format === "fixedStep") {
-        const ss = (wig.index * wig.step) + wig.start;
-        const ee = ss + wig.span;
-        const value = Number(tokens[0]);
-        ++(wig.index);
-        return isNaN(value) ? null : {chr: wig.chrom, start: ss, end: ee, value: value}
-    } else if (wig && wig.format === "variableStep") {
-
-        if (tokens.length < 2) return null
-        const ss = parseInt(tokens[0], 10) - 1;
-        const ee = ss + wig.span;
-        const value = Number(tokens[1]);
-        return isNaN(value) ? null : {chr: wig.chrom, start: ss, end: ee, value: value}
-
-    } else {
-        return decodeBedGraph(tokens)
-    }
-}
-
-function decodeSNP(tokens, header) {
-
-    if (tokens.length < 6) return undefined
-
-    const autoSql = [
-        'bin',
-        'chr',
-        'start',
-        'end',
-        'name',
-        'score',
-        'strand',
-        'refNCBI',
-        'refUCSC',
-        'observed',
-        'molType',
-        'class',
-        'valid',
-        'avHet',
-        'avHetSE',
-        'func',
-        'locType',
-        'weight',
-        'exceptions',
-        'submitterCount',
-        'submitters',
-        'alleleFreqCount',
-        'alleles',
-        'alleleNs',
-        'alleleFreqs',
-        'bitfields'
-    ];
-
-
-    const feature = {
-        chr: tokens[1],
-        start: Number.parseInt(tokens[2]),
-        end: Number.parseInt(tokens[3]),
-        name: tokens[4],
-        score: Number.parseInt(tokens[5])
-    };
-
-    const n = Math.min(tokens.length, autoSql.length);
-    for (let i = 6; i < n; i++) {
-        feature[autoSql[i]] = tokens[i];
-    }
-    return feature
-
-}
-
-
-class UCSCBedFeature {
-
-    constructor(properties) {
-        Object.assign(this, properties);
-    }
-
-    getAttributeValue(attributeName) {
-        if (this.hasOwnProperty(attributeName)) {
-            return this[attributeName]
-        } else if (this.attributes) {
-            return this.attributes[attributeName]
-        }
-    }
-}
-
-/*
-* 0 matches - Number of bases that match that aren't repeats
-* 1 misMatches - Number of bases that don't match
-* 2 repMatches - Number of bases that match but are part of repeats
-* 3 nCount - Number of "N" bases
-* 4 qNumInsert - Number of inserts in query
-* 5 qBaseInsert - Number of bases inserted in query
-* 6 tNumInsert - Number of inserts in target
-* 7 tBaseInsert - Number of bases inserted in target
-* 8 strand - "+" or "-" for query strand. For translated alignments, second "+"or "-" is for target genomic strand.
-* 9 qName - Query sequence name
-* 10 qSize - Query sequence size.
-* 11 qStart - Alignment start position in query
-* 12 qEnd - Alignment end position in query
-* 13 tName - Target sequence name
-* 14 tSize - Target sequence size
-* 15 tStart - Alignment start position in target
-* 16 tEnd - Alignment end position in target
-* 17 blockCount - Number of blocks in the alignment (a block contains no gaps)
-* 18 blockSizes - Comma-separated list of sizes of each block. If the query is a protein and the target the genome, blockSizes are in amino acids. See below for more information on protein query PSLs.
-* 19 qStarts - Comma-separated list of starting positions of each block in query
-* 20 tStarts - Comma-separated list of starting positions of each block in target
- */
-
-class PSLFeature {
-
-
-    constructor(properties) {
-        Object.assign(this, properties);
-    }
-
-    get score() {
-        const tokens = this.tokens;
-        const match = parseInt(tokens[0]);
-        const repMatch = parseInt(tokens[2]);
-        const misMatch = parseInt(tokens[1]);
-        const qGapCount = parseInt(tokens[4]);
-        const tGapCount = parseInt(tokens[6]);
-        const qSize = parseInt(tokens[10]);
-        return Math.floor((1000 * (match + repMatch - misMatch - qGapCount - tGapCount)) / qSize)
-    }
-
-    get matches() {
-        return this.tokens[0]
-    }
-
-    get misMatches() {
-        return this.tokens[1]
-    }
-
-    get repMatches() {
-        return this.tokens[2]
-    }
-
-    get nCount() {
-        return this.tokens[3]
-    }
-
-    get qNumInsert() {
-        return this.tokens[4]
-    }
-
-    get qBaseInsert() {
-        return this.tokens[5]
-    }
-
-    get tNumInsert() {
-        return this.tokens[6]
-    }
-
-    get tBaseInsert() {
-        return this.tokens[7]
-
-    }
-
-    popupData() {
-        return [
-            {name: 'chr', value: this.chr},
-            {name: 'start', value: this.start + 1},
-            {name: 'end', value: this.end},
-            {name: 'strand', value: this.strand},
-            {name: 'score', value: this.score},
-            {name: 'match', value: this.matches},
-            {name: "mis-match", value: this.misMatches},
-            {name: "rep. match", value: this.repMatches},
-            {name: "N's", value: this.nCount},
-            {name: 'Q gap count', value: this.qNumInsert},
-            {name: 'Q gap bases', value: this.qBaseInsert},
-            {name: 'T gap count', value: this.tNumInsert},
-            {name: 'T gap bases', value: this.tBaseInsert},
-        ]
-    }
-
-}
-
-/**
- * Some interpretations of the sequence ontology needed to assemble GFF transcripts.
- *
- */
-
-const transcriptTypes = new Set(['transcript', 'primary_transcript', 'processed_transcript', 'mRNA', 'mrna',
-    'lnc_RNA', 'miRNA', 'ncRNA', 'rRNA', 'scRNA', 'snRNA', 'snoRNA', 'tRNA']);
-const cdsTypes = new Set(['CDS', 'cds']);
-const codonTypes = new Set(['start_codon', 'stop_codon']);
-const utrTypes = new Set(['5UTR', '3UTR', 'UTR', 'five_prime_UTR', 'three_prime_UTR', "3'-UTR", "5'-UTR"]);
-const exonTypes = new Set(['exon', 'coding-exon']);
-
-const transcriptPartTypes = new Set();
-for (let cltn of [cdsTypes, codonTypes, utrTypes, exonTypes]) {
-    for (let t of cltn) {
-        transcriptPartTypes.add(t);
-    }
-}
-
-function isExon(type) {
-    return exonTypes.has(type)
-}
-
-function isIntron(type) {
-    return type.includes("intron")
-}
-
-function isCoding(type) {
-    return cdsTypes.has(type) || codonTypes.has(type)
-}
-
-function isUTR(type) {
-    return utrTypes.has(type)
-}
-
-function isTranscript(type) {
-    return transcriptTypes.has(type) || type.endsWith("RNA") || type.endsWith("transcript")
-}
-
-function isTranscriptPart(type) {
-    return transcriptPartTypes.has(type) || type.endsWith("RNA") || isIntron(type)
-}
-
-const filterPopupProperties = new Set(["id", "parent", "name"]);
-
-class GFFFeature {
-
-    constructor(properties) {
-
-        Object.assign(this, properties);
-
-        if (properties.phase !== undefined && "." !== properties.phase) {
-            this.readingFrame = (3 - parseInt(properties.phase)) % 3;
-        }
-
-    }
-
-
-    popupData(genomicLocation) {
-
-        const pd = this.geneObject ? this.geneObject.popupData() : [];
-
-        if (this.geneObject) {
-            pd.push('<hr/>');
-        }
-
-        if (this.name) {
-            pd.push({name: 'Name', value: this.name});
-        }
-
-        pd.push({name: 'Type', value: this.type});
-        pd.push({name: 'Source', value: this.source});
-        if (this.score !== undefined) {
-            pd.push({name: 'Score', value: this.score});
-        }
-        pd.push({name: 'Phase', value: this.phase});
-
-        if (this.attributeString) {
-            const atts = parseAttributeString(this.attributeString, this.delim);
-            for (let [key, value] of atts) {
-                if (value !== undefined && value.length > 0 && !filterPopupProperties.has(key.toLowerCase())) {
-                    pd.push({name: key + ":", value: value});
-                }
-            }
-        }
-        pd.push({
-            name: 'Location',
-            value: `${this.chr}:${numberFormatter$1(this.start + 1)}-${numberFormatter$1(this.end)}`
-        });
-        return pd
-    }
-
-    getAttributeValue(attributeName) {
-        if (this.hasOwnProperty(attributeName)) {
-            return this[attributeName]
-        } else {
-            // TODO -- fetch from attribute string and cache
-            if (!this._attributeCache) {
-                this._attributeCache = new Map();
-            }
-            if (this._attributeCache.has(attributeName)) {
-                return this._attributeCache.get(attributeName)
-            } else {
-                const atts = parseAttributeString(this.attributeString, this.delim);
-                let v;
-                for (let [key, value] of atts) {
-                    if (key === attributeName) {
-                        v = value;
-                        break
-                    }
-                }
-                this._attributeCache.set(attributeName, v);
-                return v
-            }
-        }
-    }
-}
-
-class GFFTranscript extends GFFFeature {
-
-    constructor(feature) {
-        super(feature);
-        this.exons = [];
-        this.parts = [];
-    }
-
-    addExon(feature) {
-
-        this.exons.push(feature);
-
-        // Expand feature --  for transcripts not explicitly represented in the file (gtf)
-        this.start = Math.min(this.start, feature.start);
-        this.end = Math.max(this.end, feature.end);
-    }
-
-    addPart(feature) {
-        this.parts.push(feature);
-    }
-
-    assembleParts() {
+    }
 
-        if (this.parts.length === 0) return
+    return feature
+}
 
-        this.parts.sort(function (a, b) {
-            return a.start - b.start
-        });
+function decodeWig(tokens, header) {
 
-        // Create exons, if neccessary
-        let lastStart = this.parts[0].start;
-        let lastEnd = this.parts[0].end;
-        for (let i = 1; i < this.parts.length; i++) {
-            const part = this.parts[i];
-            if (isIntron(part.type)) {
-                continue
-            }
-            if (part.start <= lastEnd) {
-                lastEnd = Math.max(lastEnd, part.end);
-            } else {
-                let exon = this.findExonContaining({start: lastStart, end: lastEnd});
-                if (!exon) {
-                    this.exons.push({start: lastStart, end: lastEnd, psuedo: true});
-                }
-                lastStart = part.start;
-                lastEnd = part.end;
-            }
-        }
-        let exon = this.findExonContaining({start: lastStart, end: lastEnd});
-        if (!exon) {
-            this.exons.push({start: lastStart, end: lastEnd, psuedo: true});
-            this.start = Math.min(this.start, lastStart);
-            this.end = Math.max(this.end, lastEnd);
-        }
+    const wig = header.wig;
 
+    if (wig && wig.format === "fixedStep") {
+        const ss = (wig.index * wig.step) + wig.start;
+        const ee = ss + wig.span;
+        const value = Number(tokens[0]);
+        ++(wig.index);
+        return isNaN(value) ? null : {chr: wig.chrom, start: ss, end: ee, value: value}
+    } else if (wig && wig.format === "variableStep") {
 
-        for (let part of this.parts) {
-            const type = part.type;
-            if (isCoding(type)) {
-                this.addCDS(part);
-            } else if (isUTR(type)) {
-                this.addUTR(part);
-            }
-        }
-    }
+        if (tokens.length < 2) return null
+        const ss = parseInt(tokens[0], 10) - 1;
+        const ee = ss + wig.span;
+        const value = Number(tokens[1]);
+        return isNaN(value) ? null : {chr: wig.chrom, start: ss, end: ee, value: value}
 
-    findExonContaining({start, end}) {
-        for (let exon of this.exons) {
-            if (exon.end >= end && exon.start <= start) {
-                return exon
-            }
-        }
-        return undefined
+    } else {
+        return decodeBedGraph(tokens)
     }
+}
 
-    addCDS(cds) {
+function decodeSNP(tokens, header) {
 
-        let exon;
-        const exons = this.exons;
+    if (tokens.length < 6) return undefined
 
-        for (let e of exons) {
-            if (e.start <= cds.start && e.end >= cds.end) {
-                exon = e;
-                break
-            }
-        }
+    const autoSql = [
+        'bin',
+        'chr',
+        'start',
+        'end',
+        'name',
+        'score',
+        'strand',
+        'refNCBI',
+        'refUCSC',
+        'observed',
+        'molType',
+        'class',
+        'valid',
+        'avHet',
+        'avHetSE',
+        'func',
+        'locType',
+        'weight',
+        'exceptions',
+        'submitterCount',
+        'submitters',
+        'alleleFreqCount',
+        'alleles',
+        'alleleNs',
+        'alleleFreqs',
+        'bitfields'
+    ];
 
-        if (exon) {
-            exon.cdStart = exon.cdStart ? Math.min(cds.start, exon.cdStart) : cds.start;
-            exon.cdEnd = exon.cdEnd ? Math.max(cds.end, exon.cdEnd) : cds.end;
-            exon.readingFrame = cds.readingFrame;
-            // TODO -- merge attributes?
-        } else {
-            // cds.cdStart = cds.start
-            // cds.cdEnd = cds.end
-            // exons.push(cds)
-            console.error("No exon found spanning " + cds.start + "-" + cds.end);
-        }
 
-        // Expand feature --  for transcripts not explicitly represented in the file (gtf files)
-        // this.start = Math.min(this.start, cds.start);
-        // this.end = Math.max(this.end, cds.end);
+    const feature = {
+        chr: tokens[1],
+        start: Number.parseInt(tokens[2]),
+        end: Number.parseInt(tokens[3]),
+        name: tokens[4],
+        score: Number.parseInt(tokens[5])
+    };
 
-        this.cdStart = this.cdStart ? Math.min(cds.start, this.cdStart) : cds.start;
-        this.cdEnd = this.cdEnd ? Math.max(cds.end, this.cdEnd) : cds.end;
+    const n = Math.min(tokens.length, autoSql.length);
+    for (let i = 6; i < n; i++) {
+        feature[autoSql[i]] = tokens[i];
     }
+    return feature
 
-    addUTR(utr) {
+}
 
-        let exon;
-        const exons = this.exons;
 
-        // Find exon containing CDS
-        for (let i = 0; i < exons.length; i++) {
-            if (exons[i].start <= utr.start && exons[i].end >= utr.end) {
-                exon = exons[i];
-                break
-            }
-        }
+class UCSCBedFeature {
 
-        if (exon) {
-            if (utr.start === exon.start && utr.end === exon.end) {
-                exon.utr = true;
-            } else {
-                if (utr.end < exon.end) {
-                    exon.cdStart = utr.end;
-                }
-                if (utr.start > exon.start) {
-                    exon.cdEnd = utr.start;
-                }
-            }
+    constructor(properties) {
+        Object.assign(this, properties);
+    }
 
-        } else {
-            // utr.utr = true
-            // exons.push(utr)
-            console.error("No exon found spanning " + cds.start + "-" + cds.end);
+    getAttributeValue(attributeName) {
+        if (this.hasOwnProperty(attributeName)) {
+            return this[attributeName]
+        } else if (this.attributes) {
+            return this.attributes[attributeName]
         }
+    }
+}
 
-        // Expand feature --  for transcripts not explicitly represented in the file
-        // this.start = Math.min(this.start, utr.start);
-        // this.end = Math.max(this.end, utr.end);
+/*
+* 0 matches - Number of bases that match that aren't repeats
+* 1 misMatches - Number of bases that don't match
+* 2 repMatches - Number of bases that match but are part of repeats
+* 3 nCount - Number of "N" bases
+* 4 qNumInsert - Number of inserts in query
+* 5 qBaseInsert - Number of bases inserted in query
+* 6 tNumInsert - Number of inserts in target
+* 7 tBaseInsert - Number of bases inserted in target
+* 8 strand - "+" or "-" for query strand. For translated alignments, second "+"or "-" is for target genomic strand.
+* 9 qName - Query sequence name
+* 10 qSize - Query sequence size.
+* 11 qStart - Alignment start position in query
+* 12 qEnd - Alignment end position in query
+* 13 tName - Target sequence name
+* 14 tSize - Target sequence size
+* 15 tStart - Alignment start position in target
+* 16 tEnd - Alignment end position in target
+* 17 blockCount - Number of blocks in the alignment (a block contains no gaps)
+* 18 blockSizes - Comma-separated list of sizes of each block. If the query is a protein and the target the genome, blockSizes are in amino acids. See below for more information on protein query PSLs.
+* 19 qStarts - Comma-separated list of starting positions of each block in query
+* 20 tStarts - Comma-separated list of starting positions of each block in target
+ */
+
+class PSLFeature {
 
+
+    constructor(properties) {
+        Object.assign(this, properties);
     }
 
-    finish() {
+    get score() {
+        const tokens = this.tokens;
+        const match = parseInt(tokens[0]);
+        const repMatch = parseInt(tokens[2]);
+        const misMatch = parseInt(tokens[1]);
+        const qGapCount = parseInt(tokens[4]);
+        const tGapCount = parseInt(tokens[6]);
+        const qSize = parseInt(tokens[10]);
+        return Math.floor((1000 * (match + repMatch - misMatch - qGapCount - tGapCount)) / qSize)
+    }
 
-        this.assembleParts();
+    get matches() {
+        return this.tokens[0]
+    }
 
-        var cdStart = this.cdStart;
-        var cdEnd = this.cdEnd;
+    get misMatches() {
+        return this.tokens[1]
+    }
 
-        this.exons.sort(function (a, b) {
-            return a.start - b.start
-        });
+    get repMatches() {
+        return this.tokens[2]
+    }
 
-        // Search for UTR exons that were not explicitly tagged
-        if (cdStart) {
-            this.exons.forEach(function (exon) {
-                if (exon.end < cdStart || exon.start > cdEnd) exon.utr = true;
-            });
-        }
+    get nCount() {
+        return this.tokens[3]
     }
 
-    popupData(genomicLocation) {
+    get qNumInsert() {
+        return this.tokens[4]
+    }
 
-        const pd = super.popupData(genomicLocation);
+    get qBaseInsert() {
+        return this.tokens[5]
+    }
 
-        // If clicked over an exon add its attributes
-        for (let exon of this.exons) {
-            if (exon.pseudo) continue  // An implicit exon
-            if (genomicLocation >= exon.start && genomicLocation < exon.end && typeof exon.popupData === 'function') {
-                pd.push('<hr/>');
-                const exonData = exon.popupData(genomicLocation);
-                for (let att of exonData) {
-                    pd.push(att);
-                }
-            }
-        }
+    get tNumInsert() {
+        return this.tokens[6]
+    }
 
-        for (let part of this.parts) {
-            if (genomicLocation >= part.start && genomicLocation < part.end && typeof part.popupData === 'function') {
-                pd.push('<hr/>');
-                const partData = part.popupData(genomicLocation);
-                for (let att of partData) {
-                    pd.push(att);
-                }
-            }
-        }
+    get tBaseInsert() {
+        return this.tokens[7]
 
+    }
 
-        return pd
+    popupData() {
+        return [
+            {name: 'chr', value: this.chr},
+            {name: 'start', value: this.start + 1},
+            {name: 'end', value: this.end},
+            {name: 'strand', value: this.strand},
+            {name: 'score', value: this.score},
+            {name: 'match', value: this.matches},
+            {name: "mis-match", value: this.misMatches},
+            {name: "rep. match", value: this.repMatches},
+            {name: "N's", value: this.nCount},
+            {name: 'Q gap count', value: this.qNumInsert},
+            {name: 'Q gap bases', value: this.qBaseInsert},
+            {name: 'T gap count', value: this.tNumInsert},
+            {name: 'T gap bases', value: this.tBaseInsert},
+        ]
     }
+
 }
 
 function decode(tokens, header) {
@@ -25920,223 +26145,6 @@ function decodeShoebox(tokens, header, maxColumnCount = Number.MAX_SAFE_INTEGER)
     return feature
 }
 
-const gffNameFields = ["Name", "transcript_id", "gene_name", "gene", "gene_id", "alias", "locus", "name" ];
-
-class GFFHelper {
-
-    constructor(options) {
-        this.format = options.format;
-        this.nameField = options.nameField;
-        this.filterTypes = options.filterTypes === undefined ?
-            new Set(['chromosome']) :
-            new Set(options.filterTypes);
-    }
-
-    combineFeatures(features, genomicInterval) {
-
-        let combinedFeatures;
-
-        const filterTypes = this.filterTypes;
-        features = features.filter(f => filterTypes === undefined || !filterTypes.has(f.type));
-
-        if ("gff3" === this.format) {
-            const tmp = this.combineFeaturesById(features);
-            combinedFeatures = this.combineFeaturesByType(tmp);
-        } else {
-            combinedFeatures = this.combineFeaturesByType(features);
-        }
-
-        this.numberExons(combinedFeatures, genomicInterval);
-        this.nameFeatures(combinedFeatures);
-        return combinedFeatures
-    }
-
-    /**
-     * Combine multiple non-transcript model features with the same ID on the same chromosome into a single feature.
-     * Features that are part of the transcript model (e.g. exon, mRNA, etc) are combined later.
-     *
-     * @param features
-     * @returns {[]}
-     */
-    combineFeaturesById(features) {
-
-        const chrIdMap = new Map();
-        const combinedFeatures = [];
-
-        for (let f of features) {
-            if (isTranscriptPart(f.type) || isTranscript(f.type) || !f.id) {
-                combinedFeatures.push(f);
-            } else {
-                let idMap = chrIdMap.get(f.chr);
-                if (!idMap) {
-                    idMap = new Map();
-                    chrIdMap.set(f.chr, idMap);
-                }
-
-                let featureArray = idMap.get(f.id);
-                if (featureArray) {
-                    featureArray.push(f);
-                } else {
-                    idMap.set(f.id, [f]);
-                }
-            }
-        }
-
-        for (let idMap of chrIdMap.values()) {
-            for (let featureArray of idMap.values()) {
-                if (featureArray.length > 1) {
-                    // Use the first feature as prototypical (for column 9 attributes), and adjust start/end
-                    // Parts are represented as "exons", as that is how they are presented visually
-                    const cf = featureArray[0];
-                    cf.exons = [];
-                    for (let f of featureArray) {
-                        cf.start = Math.min(cf.start, f.start);
-                        cf.end = Math.max(cf.end, f.end);
-                        cf.exons.push({
-                            start: f.start,
-                            end: f.end
-                        });
-                    }
-                    combinedFeatures.push(cf);
-                } else {
-                    combinedFeatures.push(featureArray[0]);
-                }
-            }
-        }
-
-        return combinedFeatures
-    }
-
-    combineFeaturesByType(features) {
-
-        // Build dictionary of genes
-        const genes = features.filter(f => "gene" === f.type || f.type.endsWith("_gene"));
-        const geneMap = Object.create(null);
-        for (let g of genes) {
-            geneMap[g.id] = g;
-        }
-
-        // 1. Build dictionary of transcripts
-        const transcripts = Object.create(null);
-        const combinedFeatures = [];
-        const consumedFeatures = new Set();
-        const filterTypes = this.filterTypes;
-
-        features = features.filter(f => filterTypes === undefined || !filterTypes.has(f.type));
-
-        for (let f of features) {
-            if (isTranscript(f.type)) {
-                const transcriptId = f.id; // getAttribute(f.attributeString, "transcript_id", /\s+/);
-                if (undefined !== transcriptId) {
-                    const gffTranscript = new GFFTranscript(f);
-                    transcripts[transcriptId] = gffTranscript;
-                    combinedFeatures.push(gffTranscript);
-                    consumedFeatures.add(f);
-                    const g = geneMap[f.parent];
-                    if (g) {
-                        gffTranscript.geneObject = g;
-                        consumedFeatures.add(g);
-                    }
-                }
-            }
-        }
-
-        // Add exons and transcript parts
-        for (let f of features) {
-            if (isTranscriptPart(f.type)) {
-                const parents = getParents(f);
-                if (parents) {
-                    for (let id of parents) {
-
-                        let transcript = transcripts[id];
-                        if (!transcript && this.format === "gtf") {
-                            // GTF does not require explicit a transcript or mRNA record, start one with this feature.
-                            const psuedoTranscript = Object.assign({}, f);
-                            psuedoTranscript.type = "transcript";
-                            transcript = new GFFTranscript(psuedoTranscript);
-                            transcripts[id] = transcript;
-                            combinedFeatures.push(transcript);
-                        }
-                        if (transcript !== undefined) {
-
-                            if (isExon(f.type)) {
-                                if (parents.length > 1) {
-                                    // Multiple parents, this is unusual.  Make a copy as exon can be modified
-                                    // differently by CDS, etc, for each parent
-                                    const e2 = new GFFFeature(f);
-                                    transcript.addExon(e2);
-                                } else {
-                                    transcript.addExon(f);
-                                }
-                            } else {
-                                transcript.addPart(f);
-                            }
-                            consumedFeatures.add(f);
-                        }
-                    }
-                }
-            }
-        }
-
-        // Finish transcripts
-        combinedFeatures.forEach(function (f) {
-            if (typeof f.finish === "function") {
-                f.finish();
-            }
-        });
-
-        // Add other features
-        const others = features.filter(f => !consumedFeatures.has(f));
-        for (let f of others) {
-            combinedFeatures.push(f);
-        }
-
-        return combinedFeatures
-
-        function getParents(f) {
-            if (f.parent && f.parent.trim() !== "") {
-                return f.parent.trim().split(",")
-            } else {
-                return null
-            }
-        }
-    }
-
-    numberExons(features, genomicInterval) {
-
-        for (let f of features) {
-            if (f.exons &&
-                (!genomicInterval ||
-                    (f.end <= genomicInterval.end && f.start > genomicInterval.start))) {
-                for (let i = 0; i < f.exons.length; i++) {
-                    const exon = f.exons[i];
-                    exon.number = f.strand === "-" ? f.exons.length - i : i + 1;
-                }
-            }
-        }
-    }
-
-    nameFeatures(features) {
-        // Find name (label) property
-        for (let f of features) {
-            if(typeof f.getAttributeValue === 'function') {
-
-                if (this.nameField) {
-                    f.name = f.getAttributeValue(this.nameField);
-                } else {
-                    for (let nameField of gffNameFields) {
-                        const v = f.getAttributeValue(nameField);
-                        if (v) {
-                            f.name = v;
-                            break
-                        }
-                    }
-                }
-            }
-        }
-    }
-}
-
 /**
  * Utilities for creating and registering custom file formats for generic delimited files.  A format definition consists
  * of an ordered list of fields, and optional delimiter specified.
@@ -33157,7 +33165,7 @@ class BWReader {
         if (this.type === "bigwig") {
             return "wig"
         } else {
-            return this.autoSql && this.autoSql.table === "chromatinInteract" ? "interact" : "annotation"
+            return this.autoSql && ("interact" === this.autoSql.table || "chromatinInteract" === this.autoSql.table) ? "interact" : "annotation"
         }
     }
 
@@ -40057,8 +40065,8 @@ class TrackViewport extends Viewport {
     checkZoomIn() {
 
         const zoomedOutOfWindow = () => {
-            if (this.referenceFrame.chr.toLowerCase() === "all" && !this.trackView.track.supportsWholeGenome) {
-                return true
+            if (this.referenceFrame.chr.toLowerCase() === "all") {
+                return !this.trackView.track.supportsWholeGenome
             } else {
                 const visibilityWindow = this.trackView.track.visibilityWindow;
                 return (
@@ -60022,7 +60030,7 @@ class InteractionTrack extends TrackBase {
     }
 
     get supportsWholeGenome() {
-        return true
+        return typeof this.featureSource.supportsWholeGenome === 'function' ? this.featureSource.supportsWholeGenome() : true;
     }
 
     async getFeatures(chr, start, end) {
@@ -72568,7 +72576,7 @@ function createReferenceFrameList(loci, genome, browserFlanking, minimumBases, v
     })
 }
 
-const _version = "3.1.2";
+const _version = "3.1.4";
 function version() {
     return _version
 }
@@ -76330,15 +76338,6 @@ class Browser {
         this.root = div({class: 'igv-container'});
         shadowRoot.appendChild(this.root);
 
-        // spinner
-        this.spinner = div({class: 'igv-loading-spinner-container'});
-        this.root.appendChild(this.spinner);
-
-        this.spinner.appendChild(div());
-        this.spinner.style.width = '64px';
-        this.spinner.style.height = '64px';
-        this.stopSpinner();
-
         this.alert = new Alert(this.root);
 
         this.columnContainer = div({class: 'igv-column-container'});
@@ -76414,14 +76413,6 @@ class Browser {
         return this.roiManager.roiTableIsVisible()
     }
 
-    startSpinner() {
-        this.spinner.style.display = 'flex';
-    }
-
-    stopSpinner() {
-        this.spinner.style.display = 'none';
-    }
-
     initialize(config) {
 
         this.flanking = config.flanking;
@@ -78770,9 +78761,6 @@ async function createBrowser(parentDiv, config) {
     const browser = new Browser(config, parentDiv);
     allBrowsers.push(browser);
 
-    // Lod initial sessio
-    browser.startSpinner();
-
     const sessionURL = config.sessionURL || config.session || config.hubURL;
     if (sessionURL) {
         await browser.loadSession({
@@ -78782,7 +78770,6 @@ async function createBrowser(parentDiv, config) {
         await browser.loadSessionObject(config);
     }
 
-    browser.stopSpinner();
     browser.navbar.navbarDidResize();
 
     return browser