igv 3.1.3 → 3.1.4

package/dist/igv.js

@@ -19437,7 +19437,7 @@
        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,
@@ -19476,8 +19476,10 @@
      };
    }
    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);
@@ -19633,7 +19635,7 @@
    // 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
@@ -19733,9 +19735,9 @@
    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;
@@ -20754,7 +20756,11 @@
        }
        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) {
@@ -24670,6 +24676,533 @@
        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.
@@ -24682,7 +25215,7 @@
 
        if (tokens.length < 3) return undefined
 
-       header && header.gffTags;
+       const gffTags = header && header.gffTags;
 
        const chr = tokens[0];
        const start = parseInt(tokens[1]);
@@ -24702,12 +25235,16 @@
                    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];
                }
            }
@@ -25125,506 +25662,194 @@
            let colorColumn = header.colorColumn;
            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) {
@@ -25926,223 +26151,6 @@
        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.
@@ -72574,7 +72582,7 @@
        })
    }
 
-   const _version = "3.1.3";
+   const _version = "3.1.4";
    function version() {
        return _version
    }
@@ -76336,15 +76344,6 @@
            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'});
@@ -76420,14 +76419,6 @@
            return this.roiManager.roiTableIsVisible()
        }
 
-       startSpinner() {
-           this.spinner.style.display = 'flex';
-       }
-
-       stopSpinner() {
-           this.spinner.style.display = 'none';
-       }
-
        initialize(config) {
 
            this.flanking = config.flanking;
@@ -78776,9 +78767,6 @@
        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({
@@ -78788,7 +78776,6 @@
            await browser.loadSessionObject(config);
        }
 
-       browser.stopSpinner();
        browser.navbar.navbarDidResize();
 
        return browser