igv 3.5.2 → 3.5.4

package/dist/igv.esm.js

@@ -386,12 +386,12 @@ function numberFormatter$1(rawNumber) {
         decsep = '.';
 
     return dec[0].split('').reverse().reduce(function (prev, now, i) {
-        return i % 3 === 0 ? prev + sep + now : prev + now;
-    }).split('').reverse().join('') + (dec[1] ? decsep + dec[1] : '');
+        return i % 3 === 0 ? prev + sep + now : prev + now
+    }).split('').reverse().join('') + (dec[1] ? decsep + dec[1] : '')
 }
 
 const splitLines$3 = function (string) {
-    return string.split(/\n|\r\n|\r/g);
+    return string.split(/\n|\r\n|\r/g)
 };
 
 
@@ -419,24 +419,24 @@ function splitStringRespectingQuotes(string, delim) {
             }
         }
     }
-    return tokens;
+    return tokens
 }
 
 function stripQuotes$2(str) {
-    if(str === undefined) {
-        return str;
+    if (str === undefined) {
+        return str
     }
-    if(str.startsWith("'") || str.startsWith('"')) {
+    if (str.startsWith("'") || str.startsWith('"')) {
         str = str.substring(1);
     }
     if (str.endsWith("'") || str.endsWith('"')) {
         str = str.substring(0, str.length - 1);
     }
-    return str;
+    return str
 }
 
 function capitalize(str) {
-    return str.length > 0 ? str.charAt(0).toUpperCase() + str.slice(1) : str;
+    return str.length > 0 ? str.charAt(0).toUpperCase() + str.slice(1) : str
 }
 
 
@@ -460,7 +460,7 @@ function parseLocusString$1(string) {
         range.end = range.start + 1;
     }
 
-    return range;
+    return range
 }
 
 /**
@@ -469,7 +469,7 @@ function parseLocusString$1(string) {
  * @param urlOrFile
  */
 
-function getFilename$2(urlOrFile) {
+function getFilename$1(urlOrFile) {
 
     if (urlOrFile.name !== undefined) {
         return urlOrFile.name
@@ -496,8 +496,8 @@ function getFilename$2(urlOrFile) {
  * @param object
  */
 function isFile(object) {
-    if(!object) {
-        return false;
+    if (!object) {
+        return false
     }
     return typeof object !== 'function' &&
         (object instanceof File ||
@@ -517,7 +517,7 @@ function download(filename, data) {
 
 if (typeof process === 'object' && typeof window === 'undefined') {
     global.atob = function (str) {
-        return Buffer.from(str, 'base64').toString('binary');
+        return Buffer.from(str, 'base64').toString('binary')
     };
 }
 
@@ -536,7 +536,7 @@ function parseUri(str) {
         if ($1) uri[o.q.name][$1] = $2;
     });
 
-    return uri;
+    return uri
 }
 
 const options = {
@@ -559,7 +559,7 @@ const options = {
  * @returns {Promise<*>}
  */
 async function resolveURL(url) {
-    return (typeof url === 'function')  ?  url() :  url;
+    return (typeof url === 'function') ? url() : url
 }
 
 /*! pako 2.1.0 https://github.com/nodeca/pako @license (MIT AND Zlib) */
@@ -7421,7 +7421,7 @@ const FEXTRA$1 = 4;  // gzip spec F.EXTRA flag
 
 function isgzipped(data) {
     const b = ArrayBuffer.isView(data) ? data : new Uint8Array(data);
-    return b[0] ===31 && b[1] === 139;
+    return b[0] === 31 && b[1] === 139
 }
 
 /**
@@ -7431,9 +7431,9 @@ function ungzip_blocks(data) {
     const ba = ArrayBuffer.isView(data) ? data : new Uint8Array(data);
     const b = ba[3] & FEXTRA$1;
     if (b !== 0 && ba[12] === 66 && ba[13] === 67) {
-        return unbgzf(ba.buffer);
+        return unbgzf(ba.buffer)
     } else {
-        return ungzip_1$1(ba);
+        return ungzip_1$1(ba)
     }
 }
 
@@ -7459,7 +7459,7 @@ function unbgzf(data, lim) {
             const start = 12 + xlen + ptr;    // Start of CDATA
             const bytesLeft = data.byteLength - start;
             const cDataSize = bsize - xlen - 19;
-            if (bytesLeft < cDataSize || cDataSize <= 0) break;
+            if (bytesLeft < cDataSize || cDataSize <= 0) break
 
             const a = new Uint8Array(data, start, cDataSize);
             const unc = inflateRaw_1(a);
@@ -7472,13 +7472,13 @@ function unbgzf(data, lim) {
             oBlockList.push(unc);
         } catch (e) {
             console.error(e);
-            break;
+            break
         }
     }
 
     // Concatenate decompressed blocks
     if (oBlockList.length === 1) {
-        return oBlockList[0];
+        return oBlockList[0]
     } else {
         const out = new Uint8Array(totalSize);
         let cursor = 0;
@@ -7487,14 +7487,14 @@ function unbgzf(data, lim) {
             arrayCopy(b, 0, out, cursor, b.length);
             cursor += b.length;
         }
-        return out;
+        return out
     }
 }
 
 function bgzBlockSize$1(data) {
     const ba = ArrayBuffer.isView(data) ? data : new Uint8Array(data);
     const bsize = (ba[17] << 8 | ba[16]) + 1;
-    return bsize;
+    return bsize
 }
 
 // From Thomas Down's zlib implementation
@@ -7504,12 +7504,12 @@ const hasSubarray = (typeof testArray.subarray === 'function');
 
 function arrayCopy(src, srcOffset, dest, destOffset, count) {
     if (count === 0) {
-        return;
+        return
     }
     if (!src) {
-        throw "Undef src";
+        throw "Undef src"
     } else if (!dest) {
-        throw "Undef dest";
+        throw "Undef dest"
     }
     if (srcOffset === 0 && count === src.length) {
         arrayCopy_fast(src, dest, destOffset);
@@ -7546,7 +7546,7 @@ function compressString(str) {
     const compressedBytes = new deflateRaw_1(bytes);            // UInt8Arry
     const compressedString = String.fromCharCode.apply(null, compressedBytes);      // Convert to string
     let enc = btoa(compressedString);
-    return enc.replace(/\+/g, '.').replace(/\//g, '_').replace(/=/g, '-');   // URL safe
+    return enc.replace(/\+/g, '.').replace(/\//g, '_').replace(/=/g, '-')   // URL safe
 }
 
 /**
@@ -7571,7 +7571,7 @@ function uncompressString(enc) {
     for (let b of bytes) {
         str += String.fromCharCode(b);
     }
-    return str;
+    return str
 }
 
 
@@ -7601,7 +7601,7 @@ function decodeDataURI$1(dataURI, gzip) {
         }
         return plain
     } else {
-        return decodeURIComponent(dataString);      // URL encoded string -- not currently used or tested
+        return decodeURIComponent(dataString)      // URL encoded string -- not currently used or tested
     }
 }
 
@@ -7633,7 +7633,7 @@ function decodeDataURI$1(dataURI, gzip) {
 const IGVMath = {
 
     lerp: (v0, v1, t) => {
-        return (1 - t) * v0 + t * v1;
+        return (1 - t) * v0 + t * v1
     },
 
     mean: function (array) {
@@ -7646,7 +7646,7 @@ const IGVMath = {
                 n++;
             }
         }
-        return n > 0 ? t / n : 0;
+        return n > 0 ? t / n : 0
     },
 
     meanAndStdev: function (array) {
@@ -7663,7 +7663,7 @@ const IGVMath = {
                 n++;
             }
         }
-        return n > 0 ? {mean: t / n, stdev: Math.sqrt(t2 - t * t / n)} : {mean: 0, stdev: 0};
+        return n > 0 ? {mean: t / n, stdev: Math.sqrt(t2 - t * t / n)} : {mean: 0, stdev: 0}
     },
 
     median: function (numbers) {
@@ -7681,33 +7681,33 @@ const IGVMath = {
             median = numbers[(numsLen - 1) / 2];
         }
 
-        return median;
+        return median
     },
 
     // Fast percentile function for "p" near edges.  This needs profiled for p in middle (e.g. median)
     percentile: function (array, p) {
 
-        if (array.length === 0) return undefined;
+        if (array.length === 0) return undefined
 
         var k = Math.floor(array.length * ((100 - p) / 100));
         if (k === 0) {
             array.sort(function (a, b) {
                 return b - a
             });
-            return array[k];
+            return array[k]
         } else {
-            return selectElement(array, k);
+            return selectElement(array, k)
         }
 
     },
 
 
     clamp: function (value, min, max) {
-        return Math.min(Math.max(value, min), max);
+        return Math.min(Math.max(value, min), max)
     },
 
     log2: function (x) {
-        return Math.log(x) / Math.LN2;
+        return Math.log(x) / Math.LN2
     }
 
 };
@@ -7733,7 +7733,7 @@ function selectElement(array, k) {
         }
     }
 
-    return heap.content[0];
+    return heap.content[0]
 }
 
 
@@ -7760,7 +7760,7 @@ BinaryHeap.prototype = {
             this.content[0] = end;
             this.sinkDown(0);
         }
-        return result;
+        return result
     },
 
     remove: function (node) {
@@ -7768,24 +7768,24 @@ BinaryHeap.prototype = {
         // To remove a value, we must search through the array to find
         // it.
         for (var i = 0; i < length; i++) {
-            if (this.content[i] !== node) continue;
+            if (this.content[i] !== node) continue
             // When it is found, the process seen in 'pop' is repeated
             // to fill up the hole.
             var end = this.content.pop();
             // If the element we popped was the one we needed to remove,
             // we're done.
-            if (i === length - 1) break;
+            if (i === length - 1) break
             // Otherwise, we replace the removed element with the popped
             // one, and allow it to float up or sink down as appropriate.
             this.content[i] = end;
             this.bubbleUp(i);
             this.sinkDown(i);
-            break;
+            break
         }
     },
 
     size: function () {
-        return this.content.length;
+        return this.content.length
     },
 
     bubbleUp: function (n) {
@@ -7799,7 +7799,7 @@ BinaryHeap.prototype = {
             // If the parent has a lesser score, things are in order and we
             // are done.
             if (score >= parent)
-                break;
+                break
 
             // Otherwise, swap the parent with the current element and
             // continue.
@@ -7839,7 +7839,7 @@ BinaryHeap.prototype = {
             }
 
             // No need to swap further, we are done.
-            if (swap == null) break;
+            if (swap == null) break
 
             // Otherwise, swap and continue.
             this.content[n] = this.content[swap];
@@ -8433,145 +8433,78 @@ function regExpEscape(s) {
 }
 
 function isGoogleURL(url) {
-    return (url.includes("googleapis") && !url.includes("urlshortener")) ||
-        isGoogleStorageURL(url) ||
-        isGoogleDriveURL(url)
-}
-
-function isGoogleStorageURL(url) {
-    return url.startsWith("gs://") ||
-        url.startsWith("https://www.googleapis.com/storage") ||
-        url.startsWith("https://storage.cloud.google.com") ||
-        url.startsWith("https://storage.googleapis.com");
-}
-
-function isGoogleDriveURL(url) {
-    return url.indexOf("drive.google.com") >= 0 || url.indexOf("www.googleapis.com/drive") > 0
-}
-
-/**
- * Translate gs:// urls to https
- * See https://cloud.google.com/storage/docs/json_api/v1
- * @param gsUrl
- * @returns {string|*}
- */
-function translateGoogleCloudURL(gsUrl) {
-
-    let {bucket, object} = parseBucketName(gsUrl);
-    object = encode(object);
-
-    const qIdx = gsUrl.indexOf('?');
-    const paramString = (qIdx > 0) ? gsUrl.substring(qIdx) + "&alt=media" : "?alt=media";
-
-    return `https://storage.googleapis.com/storage/v1/b/${bucket}/o/${object}${paramString}`
-}
-
-/**
- * Parse a google bucket and object name from a google storage URL.  Known forms include
- *
- * gs://BUCKET_NAME/OBJECT_NAME
- * https://storage.googleapis.com/BUCKET_NAME/OBJECT_NAME
- * https://storage.googleapis.com/storage/v1/b/BUCKET_NAME/o/OBJECT_NAME
- * https://www.googleapis.com/storage/v1/b/BUCKET_NAME/o/OBJECT_NAME"
- * https://storage.googleapis.com/download/storage/v1/b/BUCKET_NAME/o/OBJECT_NAME
- *
- * @param url
- */
-function parseBucketName(url) {
-
-    let bucket;
-    let object;
-
-    if (url.startsWith("gs://")) {
-        const i = url.indexOf('/', 5);
-        if (i >= 0) {
-            bucket = url.substring(5, i);
-            const qIdx = url.indexOf('?');
-            object = (qIdx < 0) ? url.substring(i + 1) : url.substring(i + 1, qIdx);
-        }
-
-    } else if (url.startsWith("https://storage.googleapis.com") || url.startsWith("https://storage.cloud.google.com")) {
-        const bucketIdx = url.indexOf("/v1/b/", 8);
-        if (bucketIdx > 0) {
-            const objIdx = url.indexOf("/o/", bucketIdx);
-            if (objIdx > 0) {
-                const queryIdx = url.indexOf("?", objIdx);
-                bucket = url.substring(bucketIdx + 6, objIdx);
-                object = queryIdx > 0 ? url.substring(objIdx + 3, queryIdx) : url.substring(objIdx + 3);
-            }
-
-        } else {
-            const idx1 = url.indexOf("/", 8);
-            const idx2 = url.indexOf("/", idx1+1);
-            const idx3 = url.indexOf("?", idx2);
-            if (idx2 > 0) {
-                bucket = url.substring(idx1+1, idx2);
-                object = idx3 < 0 ? url.substring(idx2+1) : url.substring(idx2+1, idx3);
-            }
-        }
-
-    } else if (url.startsWith("https://www.googleapis.com/storage/v1/b")) {
-        const bucketIdx = url.indexOf("/v1/b/", 8);
-        const objIdx = url.indexOf("/o/", bucketIdx);
-        if (objIdx > 0) {
-            const queryIdx = url.indexOf("?", objIdx);
-            bucket = url.substring(bucketIdx + 6, objIdx);
-            object = queryIdx > 0 ? url.substring(objIdx + 3, queryIdx) : url.substring(objIdx + 3);
-        }
-    }
+     return (url.includes("googleapis") && !url.includes("urlshortener")) ||
+         isGoogleStorageURL(url) ||
+         isGoogleDriveURL(url);
+ }
+
+ function isGoogleStorageURL(url) {
+     return url.startsWith("gs://") ||
+         url.startsWith("https://www.googleapis.com/storage") ||
+         url.startsWith("https://storage.cloud.google.com") ||
+         url.startsWith("https://storage.googleapis.com");
+ }
+
+ function isGoogleDriveURL(url) {
+     return url.startsWith("https://www.googleapis.com/drive/v3/files");
+ }
+
+ /**
+  * Translate gs:// urls to https
+  * See https://cloud.google.com/storage/docs/json_api/v1
+  * @param gsUrl
+  * @returns {string|*}
+  */
+ function translateGoogleCloudURL(gsUrl) {
+     try {
+         let {bucket, object} = parseBucketName(gsUrl);
+         object = encode(object);
 
-    if (bucket && object) {
-        return {
-            bucket, object
-        }
-    } else {
-        throw Error(`Unrecognized Google Storage URI: ${url}`)
-    }
+         const qIdx = gsUrl.indexOf('?');
+         let paramString = (qIdx > 0) ? gsUrl.substring(qIdx) : "";
 
-}
+         if (!paramString.includes("alt=media")) {
+             paramString = paramString ? `${paramString}&alt=media` : "?alt=media";
+         }
 
-/**
- * Percent a GCS object name.  See https://cloud.google.com/storage/docs/request-endpoints
- * Specific characters to encode:
- *   !, #, $, &, ', (, ), *, +, ,, /, :, ;, =, ?, @, [, ], and space characters.
- * @param obj
- */
+         return `https://storage.googleapis.com/storage/v1/b/${bucket}/o/${object}${paramString}`;
+     } catch (error) {
+         throw new Error(`Failed to translate Google Cloud URL: ${error.message}`);
+     }
+ }
 
-function encode(objectName) {
+ /**
+  * Parse a google bucket and object name from a google storage URL.
+  * @param url
+  */
+ function parseBucketName(url) {
+     const regex = /gs:\/\/([a-zA-Z0-9._-]+)\/([^?]+)|https?:\/\/(?:storage\.googleapis\.com|storage\.cloud\.google\.com|www\.googleapis\.com)\/(?:storage\/v1\/b\/)?([a-zA-Z0-9._-]+)\/(?:o\/)?([^?]+)/;
+     const match = url.match(regex);
+
+     if (match) {
+         const bucket = match[1] || match[3];
+         const object = match[2] || match[4];
+         if (bucket && object) {
+             return { bucket, object };
+         }
+     }
+     throw new Error(`Unrecognized Google Storage URI: ${url}`);
+ }
 
-    let result = '';
-    objectName.split('').forEach(function(letter) {
-        if(encodings$1.has(letter)) {
-            result += encodings$1.get(letter);
-        } else {
-            result += letter;
-        }
-    });
-    return result;
-}
+ /**
+  * Percent a GCS object name.  See https://cloud.google.com/storage/docs/request-endpoints
+  * @param objectName
+  */
+ function encode(objectName) {
+     return objectName.split('').map(letter => encodings$1.get(letter) || letter).join('');
+ }
 
-//	%23	%24	%25	%26	%27	%28	%29	%2A	%2B	%2C	%2F	%3A	%3B	%3D	%3F	%40	%5B	%5D
-const encodings$1 = new Map();
-encodings$1.set("!", "%21");
-encodings$1.set("#", "%23");
-encodings$1.set("$", "%24");
-encodings$1.set("%", "%25");
-encodings$1.set("&", "%26");
-encodings$1.set("'", "%27");
-encodings$1.set("(", "%28");
-encodings$1.set(")", "%29");
-encodings$1.set("*", "%2A");
-encodings$1.set("+", "%2B");
-encodings$1.set(",", "%2C");
-encodings$1.set("/", "%2F");
-encodings$1.set(":", "%3A");
-encodings$1.set(";", "%3B");
-encodings$1.set("=", "%3D");
-encodings$1.set("?", "%3F");
-encodings$1.set("@", "%40");
-encodings$1.set("[", "%5B");
-encodings$1.set("]", "%5D");
-encodings$1.set(" ", "%20");
+ const encodings$1 = new Map([
+     ["!", "%21"], ["#", "%23"], ["$", "%24"], ["%", "%25"], ["&", "%26"],
+     ["'", "%27"], ["(", "%28"], [")", "%29"], ["*", "%2A"], ["+", "%2B"],
+     [",", "%2C"], ["/", "%2F"], [":", "%3A"], [";", "%3B"], ["=", "%3D"],
+     ["?", "%3F"], ["@", "%40"], ["[", "%5B"], ["]", "%5D"], [" ", "%20"]
+ ]);
 
 // Convenience functions for the gapi oAuth library.
 
@@ -8602,7 +8535,8 @@ async function init(config) {
     // Attach an object to keep igv state
     google.igv = {
         tokenClient: tokenClient,
-        apiKey: config.apiKey
+        apiKey: config.apiKey,
+        appId: config.appId
     };
 }
 
@@ -8622,8 +8556,6 @@ function getCurrentAccessToken() {
         undefined
 }
 
-
-let promise;
 /**
  * Return a promise for an access token for the given scope.  If the user hasn't authorized the scope request it
  *
@@ -8642,27 +8574,21 @@ async function getAccessToken(scope) {
         return google.igv.tokenResponse.access_token
     } else {
         const tokenClient = google.igv.tokenClient;
-        if(!promise) {
-            promise = new Promise((resolve, reject) => {
-                try {
-                    // Settle this promise in the response callback for requestAccessToken()
-                    tokenClient.callback = (tokenResponse) => {
-                        if (tokenResponse.error !== undefined) {
-                            reject(tokenResponse);
-                        }
-                        google.igv.tokenResponse = tokenResponse;
-                        google.igv.tokenExpiresAt = Date.now() + tokenResponse.expires_in * 1000;
-                        console.log("Access token expires at " + new Date(google.igv.tokenExpiresAt));
-                        resolve(tokenResponse.access_token);
-                    };
-                    console.log("Requesting access token");
-                    tokenClient.requestAccessToken({scope});
-                } catch (err) {
-                    console.log(err);
-                }
-            });
-        }
-        return promise
+        return new Promise((resolve, reject) => {
+            tokenClient.callback = (tokenResponse) => {
+                if (tokenResponse.error !== undefined) {
+                    return reject(tokenResponse)
+                }
+                google.igv.tokenResponse = tokenResponse;
+                google.igv.tokenExpiresAt = Date.now() + tokenResponse.expires_in * 1000;
+                resolve(tokenResponse.access_token);
+            };
+            try {
+                tokenClient.requestAccessToken({scope});
+            } catch (err) {
+                reject(err);
+            }
+        })
     }
 }
 
@@ -8681,90 +8607,6 @@ function getScopeForURL(url) {
     }
 }
 
-function getApiKey() {
-    return google.igv.apiKey
-}
-
-/**
- * Return information about a specific google drive URL
- *
- * @param googleDriveURL
- * @returns {Promise<any>}
- */
-async function getDriveFileInfo(googleDriveURL) {
-
-    const id = getGoogleDriveFileID(googleDriveURL);
-    let endPoint = "https://www.googleapis.com/drive/v3/files/" + id + "?supportsTeamDrives=true";
-    const apiKey = getApiKey();
-    if (apiKey) {
-        endPoint += "&key=" + apiKey;
-    }
-    const response = await fetch(endPoint);
-    let json = await response.json();
-    if (json.error && json.error.code === 404) {
-        let scope = "https://www.googleapis.com/auth/drive.readonly";
-        const access_token = await getAccessToken(scope);
-        if (access_token) {
-            const response = await fetch(endPoint, {
-                headers: {
-                    'Authorization': `Bearer ${access_token}`
-                }
-            });
-            json = await response.json();
-            if (json.error) {
-                throw Error(json.error);
-            }
-        } else {
-            throw Error(json.error);
-        }
-    }
-    return json;
-}
-
-
-function getDriveDownloadURL(link) {
-    // Return a google drive download url for the sharable link
-    //https://drive.google.com/open?id=0B-lleX9c2pZFbDJ4VVRxakJzVGM
-    //https://drive.google.com/file/d/1_FC4kCeO8E3V4dJ1yIW7A0sn1yURKIX-/view?usp=sharing
-    var id = getGoogleDriveFileID(link);
-    return id ? "https://www.googleapis.com/drive/v3/files/" + id + "?alt=media&supportsTeamDrives=true" : link;
-}
-
-function getGoogleDriveFileID(link) {
-
-    //https://drive.google.com/file/d/1_FC4kCeO8E3V4dJ1yIW7A0sn1yURKIX-/view?usp=sharing
-    //https://www.googleapis.com/drive/v3/files/1w-tvo6p1SH4p1OaQSVxpkV_EJgGIstWF?alt=media&supportsTeamDrives=true"
-
-    if (link.includes("/open?id=")) {
-        const i1 = link.indexOf("/open?id=") + 9;
-        const i2 = link.indexOf("&");
-        if (i1 > 0 && i2 > i1) {
-            return link.substring(i1, i2)
-        } else if (i1 > 0) {
-            return link.substring(i1);
-        }
-
-    } else if (link.includes("/file/d/")) {
-        const i1 = link.indexOf("/file/d/") + 8;
-        const i2 = link.lastIndexOf("/");
-        return link.substring(i1, i2);
-
-    } else if (link.startsWith("https://www.googleapis.com/drive")) {
-        let i1 = link.indexOf("/files/");
-        const i2 = link.indexOf("?");
-        if (i1 > 0) {
-            i1 += 7;
-            return i2 > 0 ?
-                link.substring(i1, i2) :
-                link.substring(i1)
-        }
-    }
-
-    throw Error("Unknown Google Drive url format: " + link);
-
-
-}
-
 // The MIT License (MIT)
 
 /**
@@ -8796,7 +8638,7 @@ class Throttle {
                 asyncFunction: asyncFunction,
             });
             self.dequeue();
-        });
+        })
     }
 
     /**
@@ -8809,10 +8651,10 @@ class Throttle {
      */
     addAll(promises, options) {
         var addedPromises = promises.map(function (promise) {
-            return this.add(promise, options);
+            return this.add(promise, options)
         }.bind(this));
 
-        return Promise.all(addedPromises);
+        return Promise.all(addedPromises)
     };
 
     /**
@@ -8884,6 +8726,10 @@ class Throttle {
 
 class IGVXhr {
 
+    UCSC_HOST = "hgdownload.soe.ucsc.edu"
+    UCSC_BACKUP_HOST = "genome-browser.s3.us-east-1.amazonaws.com"
+
+
     constructor() {
         this.apiKey = undefined;
         this.googleThrottle = new Throttle({
@@ -8891,6 +8737,7 @@ class IGVXhr {
         });
         this.RANGE_WARNING_GIVEN = false;
         this.oauth = new Oauth();
+        this.corsProxy = undefined;
     }
 
     setApiKey(key) {
@@ -8915,7 +8762,7 @@ class IGVXhr {
      * @param options
      * @returns {Promise<Uint8Array>}
      */
-     async loadByteArray(url, options) {
+    async loadByteArray(url, options) {
         const arraybuffer = await this.loadArrayBuffer(url, options);
         let plain;
         if (isgzipped(arraybuffer)) {
@@ -8960,7 +8807,7 @@ class IGVXhr {
 
         if (isFile(url)) {
             return this._loadFileSlice(url, options)
-        } else if (typeof url.startsWith === 'function') {   // Test for string
+        } else if (isString$3(url)) {
             if (url.startsWith("data:")) {
                 const buffer = decodeDataURI$1(url).buffer;
                 if (options.range) {
@@ -8970,9 +8817,6 @@ class IGVXhr {
                     return buffer
                 }
             } else {
-                if (url.startsWith("https://drive.google.com")) {
-                    url = getDriveDownloadURL(url);
-                }
                 if (isGoogleDriveURL(url) || url.startsWith("https://www.dropbox.com")) {
                     return this.googleThrottle.add(async () => {
                         return this._loadURL(url, options)
@@ -8990,14 +8834,21 @@ class IGVXhr {
 
         const self = this;
         const _url = url;   // The unmodified URL, needed in case of an oAuth retry
+        const {host} = parseUri(_url);
 
         url = mapUrl$1(url);
 
         options = options || {};
 
-        let oauthToken = options.oauthToken || this.getOauthToken(url);
-        if (oauthToken) {
-            oauthToken = await (typeof oauthToken === 'function' ? oauthToken() : oauthToken);
+        let oauthToken;
+        if (isGoogleDriveURL(url)) {
+            // Google drive urls always require oAuth
+            oauthToken = await getAccessToken("https://www.googleapis.com/auth/drive.file");
+        } else {
+            oauthToken = options.oauthToken || this.getOauthToken(url);
+            if (oauthToken) {
+                oauthToken = await (typeof oauthToken === 'function' ? oauthToken() : oauthToken);
+            }
         }
 
         return new Promise(function (resolve, reject) {
@@ -9070,8 +8921,10 @@ class IGVXhr {
 
             xhr.onload = async function (event) {
 
+                const isFileProtocol = url.toLowerCase().startsWith("file:");
+
                 // when the url points to a local file, the status is 0
-                if (xhr.status === 0 || (xhr.status >= 200 && xhr.status <= 300)) {
+                if ((xhr.status >= 200 && xhr.status <= 300) || (isFileProtocol && xhr.status === 0)) {
                     if ("HEAD" === options.method) {
                         // Support fetching specific headers.  Attempting to fetch all headers can be problematic with CORS
                         const headers = options.requestedHeaders || ['content-length'];
@@ -9087,7 +8940,7 @@ class IGVXhr {
                             // For small files a range starting at 0 can return the whole file => 200
                             // Provide just the slice we asked for, throw out the rest quietly
                             // If file is large warn user
-                            if (xhr.response.length > 100000 && !self.RANGE_WARNING_GIVEN) {
+                            if (xhr.response.length > 1000000 && !self.RANGE_WARNING_GIVEN) {
                                 alert(`Warning: Range header ignored for URL: ${url}.  This can have severe performance impacts.`);
                             }
                             resolve(xhr.response.slice(range.start, range.start + range.size));
@@ -9104,20 +8957,29 @@ class IGVXhr {
                     tryGoogleAuth();
 
                 } else {
+                    const error = new Error(`Error accessing resource: ${url} status: ${xhr.status}`);
                     if (xhr.status === 403) {
                         handleError("Access forbidden: " + url);
+                    } else if (host === self.UCSC_HOST) {
+                        tryUcscBackup(self.UCSC_HOST, self.UCSC_BACKUP_HOST, error);
+                    } else if (xhr.status === 0 && self.corsProxy && !options.corsProxyRetried) {
+                        tryCorsProxy(error);
                     } else {
-                        handleError(xhr.status);
+                        handleError(error);
                     }
                 }
             };
 
-
             xhr.onerror = function (event) {
+                const error = new Error(`Error accessing resource: ${url} status: ${xhr.status}`);
                 if (isGoogleURL(url) && !options.retries) {
                     tryGoogleAuth();
+                } else if (host === self.UCSC_HOST) {
+                    tryUcscBackup(self.UCSC_HOST, self.UCSC_BACKUP_HOST, error);
+                } else if (self.corsProxy && !options.corsProxyRetried) {
+                    tryCorsProxy(error);
                 } else {
-                    handleError("Error accessing resource: " + url + " Status: " + xhr.status);
+                    handleError(error);
                 }
             };
 
@@ -9149,6 +9011,27 @@ class IGVXhr {
                 }
             }
 
+            async function tryCorsProxy(error) {
+                options.corsProxyRetried = true;
+                const proxyUrl = self.corsProxy + (_url.includes("?") ? "&" : "?") + "url=" + encodeURIComponent(_url);
+                try {
+                    const result = await self._loadURL(proxyUrl, options);
+                    resolve(result);
+                } catch (e) {
+                    handleError(error);
+                }
+            }
+
+            async function tryUcscBackup(UCSC_HOST, UCSC_BACKUP_HOST, error) {
+                const backupUrl = _url.replace(UCSC_HOST, UCSC_BACKUP_HOST);
+                try {
+                    const result = await self._loadURL(backupUrl, options);
+                    resolve(result);
+                } catch (e) {
+                    handleError(error);
+                }
+            }
+
             async function tryGoogleAuth() {
                 try {
                     const accessToken = await fetchGoogleAccessToken(_url);
@@ -9167,6 +9050,8 @@ class IGVXhr {
                     }
                 }
             }
+
+
         })
 
     }
@@ -9239,20 +9124,29 @@ class IGVXhr {
     }
 
     /**
-     * This method should only be called when it is known the server supports HEAD requests.  It is used to recover
-     * from 416 errors from out-of-spec WRT range request servers.  Notably Globus.
-     * * *
+     * Return the content length of the file at the given URL.  This is not guaranteed to succeed, some servers
+     * do not support or allow the content-length header.
+     *
      * @param url
      * @param options
      * @returns {Promise<unknown>}
      */
     async getContentLength(url, options) {
-        options = options || {};
-        options.method = 'HEAD';
-        options.requestedHeaders = ['content-length'];
-        const headerMap = await this._loadURL(url, options);
-        const contentLengthString = headerMap['content-length'];
-        return contentLengthString ? Number.parseInt(contentLengthString) : 0
+        if (isFile(url)) {
+            return url.size
+        } else {
+            try {
+                options = options || {};
+                options.method = 'HEAD';
+                options.requestedHeaders = ['content-length'];
+                const headerMap = await this._loadURL(url, options);
+                const contentLengthString = headerMap['content-length'];
+                return contentLengthString ? Number.parseInt(contentLengthString) : 0
+            } catch (e) {
+                console.error(e);
+                return -1
+            }
+        }
     }
 
 }
@@ -9315,8 +9209,10 @@ function addApiKey(url) {
 }
 
 function addTeamDrive(url) {
-    if (url.includes("supportsTeamDrive")) {
+    if (url.includes("supportsAllDrives")) {
         return url
+    } else if (url.includes("supportsTeamDrives")) {
+        return url.replaceAll("supportsTeamDrives", "supportsAllDrives")
     } else {
         const paramSeparator = url.includes("?") ? "&" : "?";
         url = url + paramSeparator + "supportsTeamDrive=true";
@@ -9331,8 +9227,6 @@ function mapUrl$1(url) {
 
     if (url.startsWith("https://www.dropbox.com")) {
         return url.replace("//www.dropbox.com", "//dl.dropboxusercontent.com")
-    } else if (url.startsWith("https://drive.google.com")) {
-        return getDriveDownloadURL(url)
     } else if (url.includes("//www.broadinstitute.org/igvdata")) {
         return url.replace("//www.broadinstitute.org/igvdata", "//data.broadinstitute.org/igvdata")
     } else if (url.includes("//igvdata.broadinstitute.org")) {
@@ -9528,17 +9422,17 @@ class IntervalTree$1 {
 
         var searchInterval = new Interval$1(start, end, 0);
 
-        if (this.root === NIL$1) return [];
+        if (this.root === NIL$1) return []
 
         var intervals = searchAll$1.call(this, searchInterval, this.root, []);
 
         if (intervals.length > 1) {
             intervals.sort(function (i1, i2) {
-                return i1.low - i2.low;
+                return i1.low - i2.low
             });
         }
 
-        return intervals;
+        return intervals
     }
 
     /**
@@ -9623,7 +9517,7 @@ function searchAll$1(interval, node, results) {
         searchAll$1.call(this, interval, node.right, results);
     }
 
-    return results;
+    return results
 }
 
 function leftRotate$1(x) {
@@ -9702,35 +9596,35 @@ class Interval$1 {
 
     equals(other) {
         if (!other) {
-            return false;
+            return false
         }
         if (this === other) {
-            return true;
+            return true
         }
         return (this.low === other.low &&
-            this.high === other.high);
+            this.high === other.high)
 
     }
 
     compareTo(other) {
         if (this.low < other.low)
-            return -1;
+            return -1
         if (this.low > other.low)
-            return 1;
+            return 1
 
         if (this.high < other.high)
-            return -1;
+            return -1
         if (this.high > other.high)
-            return 1;
+            return 1
 
-        return 0;
+        return 0
     }
 
     /**
      * Returns true if this interval overlaps the other.
      */
     overlaps(other) {
-            return (this.low <= other.high && other.low <= this.high);
+        return (this.low <= other.high && other.low <= this.high)
     }
 }
 
@@ -9775,19 +9669,19 @@ const FeatureUtils = {
         var start;
         var end;
 
-        if (!features) return;
+        if (!features) return
 
         maxRows = maxRows || 10000;
 
         if (!sorted) {
             features.sort(function (a, b) {
-                return a.start - b.start;
+                return a.start - b.start
             });
         }
 
 
         if (features.length === 0) {
-            return [];
+            return []
 
         } else {
 
@@ -9840,7 +9734,7 @@ const FeatureUtils = {
                     } // while (bucket)
 
                     if (!bucket) {
-                        break;
+                        break
                     }
                     feature = bucket.pop();
                     if (0 === bucket.length) {
@@ -9857,7 +9751,7 @@ const FeatureUtils = {
                 row++;
                 nextStart = bucketStart;
 
-                if (allocatedCount === lastAllocatedCount) break;   // Protect from infinite loops
+                if (allocatedCount === lastAllocatedCount) break   // Protect from infinite loops
 
                 lastAllocatedCount = allocatedCount;
 
@@ -9879,13 +9773,13 @@ const FeatureUtils = {
     findOverlapping: function (featureList, start, end) {
 
         if (!featureList || featureList.length === 0) {
-            return [];
+            return []
         } else {
             const tree = buildIntervalTree$1(featureList);
             const intervals = tree.findOverlapping(start, end);
 
             if (intervals.length === 0) {
-                return [];
+                return []
             } else {
                 // Trim the list of features in the intervals to those
                 // overlapping the requested range.
@@ -9898,7 +9792,7 @@ const FeatureUtils = {
                     const len = intervalFeatures.length;
                     for (let i = 0; i < len; i++) {
                         const feature = intervalFeatures[i];
-                        if (feature.start > end) break;
+                        if (feature.start > end) break
                         else if (feature.end > start) {
                             featureList.push(feature);
                         }
@@ -9906,10 +9800,10 @@ const FeatureUtils = {
                 });
 
                 featureList.sort(function (a, b) {
-                    return a.start - b.start;
+                    return a.start - b.start
                 });
 
-                return featureList;
+                return featureList
             }
         }
 
@@ -9930,7 +9824,7 @@ function buildIntervalTree$1(featureList) {
     const chunkSize = Math.max(10, Math.round(len / 100));
 
     featureList.sort(function (f1, f2) {
-        return (f1.start === f2.start ? 0 : (f1.start > f2.start ? 1 : -1));
+        return (f1.start === f2.start ? 0 : (f1.start > f2.start ? 1 : -1))
     });
 
     for (let i = 0; i < len; i += chunkSize) {
@@ -9944,7 +9838,7 @@ function buildIntervalTree$1(featureList) {
         tree.insert(iStart, iEnd, subArray);
     }
 
-    return tree;
+    return tree
 }
 
 function hexToRGB(hex) {
@@ -10395,7 +10289,7 @@ const doAutoscale = function (features) {
         min = Number.MAX_VALUE;
         max = -Number.MAX_VALUE;
 
-        for(let f of features) {
+        for (let f of features) {
             if (!Number.isNaN(f.value)) {
                 min = Math.min(min, f.value);
                 max = Math.max(max, f.value);
@@ -10469,19 +10363,6 @@ const isNumber = function (num) {
     return false
 };
 
-async function getFilename$1(url) {
-    if (isString$3(url) && url.startsWith("https://drive.google.com")) {
-        // This will fail if Google API key is not defined
-        if (getApiKey() === undefined) {
-            throw Error("Google drive is referenced, but API key is not defined.  An API key is required for Google Drive access")
-        }
-        const json = await getDriveFileInfo(url);
-        return json.originalFileName || json.name
-    } else {
-        return getFilename$2(url)
-    }
-}
-
 function prettyBasePairNumber(raw) {
 
     var denom,
@@ -10544,12 +10425,12 @@ function getElementVerticalDimension(element) {
     const marginTop = parseInt(style.marginTop);
     const marginBottom = parseInt(style.marginBottom);
 
-    const { top, bottom, height } = element.getBoundingClientRect();
+    const {top, bottom, height} = element.getBoundingClientRect();
     return {
         top: Math.floor(top) - marginTop,
         bottom: Math.floor(bottom) + marginBottom,
         height: Math.floor(height) + marginTop + marginBottom
-    };
+    }
 }
 
 class Popover {
@@ -10739,7 +10620,7 @@ function createMenuElements$1(itemList, popover) {
     return list;
 }
 
-/*! @license DOMPurify 3.2.7 | (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.7/LICENSE */
+/*! @license DOMPurify 3.3.0 | (c) Cure53 and other contributors | Released under the Apache license 2.0 and Mozilla Public License 2.0 | github.com/cure53/DOMPurify/blob/3.3.0/LICENSE */
 
 const {
   entries,
@@ -10925,7 +10806,7 @@ function lookupGetter(object, prop) {
 }
 
 const html$1 = freeze(['a', 'abbr', 'acronym', 'address', 'area', 'article', 'aside', 'audio', 'b', 'bdi', 'bdo', 'big', 'blink', 'blockquote', 'body', 'br', 'button', 'canvas', 'caption', 'center', 'cite', 'code', 'col', 'colgroup', 'content', 'data', 'datalist', 'dd', 'decorator', 'del', 'details', 'dfn', 'dialog', 'dir', 'div', 'dl', 'dt', 'element', 'em', 'fieldset', 'figcaption', 'figure', 'font', 'footer', 'form', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'head', 'header', 'hgroup', 'hr', 'html', 'i', 'img', 'input', 'ins', 'kbd', 'label', 'legend', 'li', 'main', 'map', 'mark', 'marquee', 'menu', 'menuitem', 'meter', 'nav', 'nobr', 'ol', 'optgroup', 'option', 'output', 'p', 'picture', 'pre', 'progress', 'q', 'rp', 'rt', 'ruby', 's', 'samp', 'search', 'section', 'select', 'shadow', 'slot', 'small', 'source', 'spacer', 'span', 'strike', 'strong', 'style', 'sub', 'summary', 'sup', 'table', 'tbody', 'td', 'template', 'textarea', 'tfoot', 'th', 'thead', 'time', 'tr', 'track', 'tt', 'u', 'ul', 'var', 'video', 'wbr']);
-const svg$1 = freeze(['svg', 'a', 'altglyph', 'altglyphdef', 'altglyphitem', 'animatecolor', 'animatemotion', 'animatetransform', 'circle', 'clippath', 'defs', 'desc', 'ellipse', 'enterkeyhint', 'exportparts', 'filter', 'font', 'g', 'glyph', 'glyphref', 'hkern', 'image', 'inputmode', 'line', 'lineargradient', 'marker', 'mask', 'metadata', 'mpath', 'part', 'path', 'pattern', 'polygon', 'polyline', 'radialgradient', 'rect', 'slot', 'stop', 'style', 'switch', 'symbol', 'text', 'textpath', 'title', 'tref', 'tspan', 'view', 'vkern']);
+const svg$1 = freeze(['svg', 'a', 'altglyph', 'altglyphdef', 'altglyphitem', 'animatecolor', 'animatemotion', 'animatetransform', 'circle', 'clippath', 'defs', 'desc', 'ellipse', 'enterkeyhint', 'exportparts', 'filter', 'font', 'g', 'glyph', 'glyphref', 'hkern', 'image', 'inputmode', 'line', 'lineargradient', 'marker', 'mask', 'metadata', 'mpath', 'part', 'path', 'pattern', 'polygon', 'polyline', 'radialgradient', 'rect', 'stop', 'style', 'switch', 'symbol', 'text', 'textpath', 'title', 'tref', 'tspan', 'view', 'vkern']);
 const svgFilters = freeze(['feBlend', 'feColorMatrix', 'feComponentTransfer', 'feComposite', 'feConvolveMatrix', 'feDiffuseLighting', 'feDisplacementMap', 'feDistantLight', 'feDropShadow', 'feFlood', 'feFuncA', 'feFuncB', 'feFuncG', 'feFuncR', 'feGaussianBlur', 'feImage', 'feMerge', 'feMergeNode', 'feMorphology', 'feOffset', 'fePointLight', 'feSpecularLighting', 'feSpotLight', 'feTile', 'feTurbulence']);
 // List of SVG elements that are disallowed by default.
 // We still need to know them so that we can do namespace
@@ -10939,7 +10820,7 @@ const mathMlDisallowed = freeze(['maction', 'maligngroup', 'malignmark', 'mlongd
 const text = freeze(['#text']);
 
 const html = freeze(['accept', 'action', 'align', 'alt', 'autocapitalize', 'autocomplete', 'autopictureinpicture', 'autoplay', 'background', 'bgcolor', 'border', 'capture', 'cellpadding', 'cellspacing', 'checked', 'cite', 'class', 'clear', 'color', 'cols', 'colspan', 'controls', 'controlslist', 'coords', 'crossorigin', 'datetime', 'decoding', 'default', 'dir', 'disabled', 'disablepictureinpicture', 'disableremoteplayback', 'download', 'draggable', 'enctype', 'enterkeyhint', 'exportparts', 'face', 'for', 'headers', 'height', 'hidden', 'high', 'href', 'hreflang', 'id', 'inert', 'inputmode', 'integrity', 'ismap', 'kind', 'label', 'lang', 'list', 'loading', 'loop', 'low', 'max', 'maxlength', 'media', 'method', 'min', 'minlength', 'multiple', 'muted', 'name', 'nonce', 'noshade', 'novalidate', 'nowrap', 'open', 'optimum', 'part', 'pattern', 'placeholder', 'playsinline', 'popover', 'popovertarget', 'popovertargetaction', 'poster', 'preload', 'pubdate', 'radiogroup', 'readonly', 'rel', 'required', 'rev', 'reversed', 'role', 'rows', 'rowspan', 'spellcheck', 'scope', 'selected', 'shape', 'size', 'sizes', 'slot', 'span', 'srclang', 'start', 'src', 'srcset', 'step', 'style', 'summary', 'tabindex', 'title', 'translate', 'type', 'usemap', 'valign', 'value', 'width', 'wrap', 'xmlns', 'slot']);
-const svg = freeze(['accent-height', 'accumulate', 'additive', 'alignment-baseline', 'amplitude', 'ascent', 'attributename', 'attributetype', 'azimuth', 'basefrequency', 'baseline-shift', 'begin', 'bias', 'by', 'class', 'clip', 'clippathunits', 'clip-path', 'clip-rule', 'color', 'color-interpolation', 'color-interpolation-filters', 'color-profile', 'color-rendering', 'cx', 'cy', 'd', 'dx', 'dy', 'diffuseconstant', 'direction', 'display', 'divisor', 'dur', 'edgemode', 'elevation', 'end', 'exponent', 'fill', 'fill-opacity', 'fill-rule', 'filter', 'filterunits', 'flood-color', 'flood-opacity', 'font-family', 'font-size', 'font-size-adjust', 'font-stretch', 'font-style', 'font-variant', 'font-weight', 'fx', 'fy', 'g1', 'g2', 'glyph-name', 'glyphref', 'gradientunits', 'gradienttransform', 'height', 'href', 'id', 'image-rendering', 'in', 'in2', 'intercept', 'k', 'k1', 'k2', 'k3', 'k4', 'kerning', 'keypoints', 'keysplines', 'keytimes', 'lang', 'lengthadjust', 'letter-spacing', 'kernelmatrix', 'kernelunitlength', 'lighting-color', 'local', 'marker-end', 'marker-mid', 'marker-start', 'markerheight', 'markerunits', 'markerwidth', 'maskcontentunits', 'maskunits', 'max', 'mask', 'media', 'method', 'mode', 'min', 'name', 'numoctaves', 'offset', 'operator', 'opacity', 'order', 'orient', 'orientation', 'origin', 'overflow', 'paint-order', 'path', 'pathlength', 'patterncontentunits', 'patterntransform', 'patternunits', 'points', 'preservealpha', 'preserveaspectratio', 'primitiveunits', 'r', 'rx', 'ry', 'radius', 'refx', 'refy', 'repeatcount', 'repeatdur', 'restart', 'result', 'rotate', 'scale', 'seed', 'shape-rendering', 'slope', 'specularconstant', 'specularexponent', 'spreadmethod', 'startoffset', 'stddeviation', 'stitchtiles', 'stop-color', 'stop-opacity', 'stroke-dasharray', 'stroke-dashoffset', 'stroke-linecap', 'stroke-linejoin', 'stroke-miterlimit', 'stroke-opacity', 'stroke', 'stroke-width', 'style', 'surfacescale', 'systemlanguage', 'tabindex', 'tablevalues', 'targetx', 'targety', 'transform', 'transform-origin', 'text-anchor', 'text-decoration', 'text-rendering', 'textlength', 'type', 'u1', 'u2', 'unicode', 'values', 'viewbox', 'visibility', 'version', 'vert-adv-y', 'vert-origin-x', 'vert-origin-y', 'width', 'word-spacing', 'wrap', 'writing-mode', 'xchannelselector', 'ychannelselector', 'x', 'x1', 'x2', 'xmlns', 'y', 'y1', 'y2', 'z', 'zoomandpan']);
+const svg = freeze(['accent-height', 'accumulate', 'additive', 'alignment-baseline', 'amplitude', 'ascent', 'attributename', 'attributetype', 'azimuth', 'basefrequency', 'baseline-shift', 'begin', 'bias', 'by', 'class', 'clip', 'clippathunits', 'clip-path', 'clip-rule', 'color', 'color-interpolation', 'color-interpolation-filters', 'color-profile', 'color-rendering', 'cx', 'cy', 'd', 'dx', 'dy', 'diffuseconstant', 'direction', 'display', 'divisor', 'dur', 'edgemode', 'elevation', 'end', 'exponent', 'fill', 'fill-opacity', 'fill-rule', 'filter', 'filterunits', 'flood-color', 'flood-opacity', 'font-family', 'font-size', 'font-size-adjust', 'font-stretch', 'font-style', 'font-variant', 'font-weight', 'fx', 'fy', 'g1', 'g2', 'glyph-name', 'glyphref', 'gradientunits', 'gradienttransform', 'height', 'href', 'id', 'image-rendering', 'in', 'in2', 'intercept', 'k', 'k1', 'k2', 'k3', 'k4', 'kerning', 'keypoints', 'keysplines', 'keytimes', 'lang', 'lengthadjust', 'letter-spacing', 'kernelmatrix', 'kernelunitlength', 'lighting-color', 'local', 'marker-end', 'marker-mid', 'marker-start', 'markerheight', 'markerunits', 'markerwidth', 'maskcontentunits', 'maskunits', 'max', 'mask', 'mask-type', 'media', 'method', 'mode', 'min', 'name', 'numoctaves', 'offset', 'operator', 'opacity', 'order', 'orient', 'orientation', 'origin', 'overflow', 'paint-order', 'path', 'pathlength', 'patterncontentunits', 'patterntransform', 'patternunits', 'points', 'preservealpha', 'preserveaspectratio', 'primitiveunits', 'r', 'rx', 'ry', 'radius', 'refx', 'refy', 'repeatcount', 'repeatdur', 'restart', 'result', 'rotate', 'scale', 'seed', 'shape-rendering', 'slope', 'specularconstant', 'specularexponent', 'spreadmethod', 'startoffset', 'stddeviation', 'stitchtiles', 'stop-color', 'stop-opacity', 'stroke-dasharray', 'stroke-dashoffset', 'stroke-linecap', 'stroke-linejoin', 'stroke-miterlimit', 'stroke-opacity', 'stroke', 'stroke-width', 'style', 'surfacescale', 'systemlanguage', 'tabindex', 'tablevalues', 'targetx', 'targety', 'transform', 'transform-origin', 'text-anchor', 'text-decoration', 'text-rendering', 'textlength', 'type', 'u1', 'u2', 'unicode', 'values', 'viewbox', 'visibility', 'version', 'vert-adv-y', 'vert-origin-x', 'vert-origin-y', 'width', 'word-spacing', 'wrap', 'writing-mode', 'xchannelselector', 'ychannelselector', 'x', 'x1', 'x2', 'xmlns', 'y', 'y1', 'y2', 'z', 'zoomandpan']);
 const mathMl = freeze(['accent', 'accentunder', 'align', 'bevelled', 'close', 'columnsalign', 'columnlines', 'columnspan', 'denomalign', 'depth', 'dir', 'display', 'displaystyle', 'encoding', 'fence', 'frame', 'height', 'href', 'id', 'largeop', 'length', 'linethickness', 'lspace', 'lquote', 'mathbackground', 'mathcolor', 'mathsize', 'mathvariant', 'maxsize', 'minsize', 'movablelimits', 'notation', 'numalign', 'open', 'rowalign', 'rowlines', 'rowspacing', 'rowspan', 'rspace', 'rquote', 'scriptlevel', 'scriptminsize', 'scriptsizemultiplier', 'selection', 'separator', 'separators', 'stretchy', 'subscriptshift', 'supscriptshift', 'symmetric', 'voffset', 'width', 'xmlns']);
 const xml = freeze(['xlink:href', 'xml:id', 'xlink:title', 'xml:space', 'xmlns:xlink']);
 
@@ -11046,7 +10927,7 @@ 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.7';
+  DOMPurify.version = '3.3.0';
   DOMPurify.removed = [];
   if (!window || !window.document || window.document.nodeType !== NODE_TYPE.document || !window.Element) {
     // Not running in a browser, provide a factory function
@@ -11157,6 +11038,21 @@ function createDOMPurify() {
   let FORBID_TAGS = null;
   /* Explicitly forbidden attributes (overrides ALLOWED_ATTR/ADD_ATTR) */
   let FORBID_ATTR = null;
+  /* Config object to store ADD_TAGS/ADD_ATTR functions (when used as functions) */
+  const EXTRA_ELEMENT_HANDLING = Object.seal(create(null, {
+    tagCheck: {
+      writable: true,
+      configurable: false,
+      enumerable: true,
+      value: null
+    },
+    attributeCheck: {
+      writable: true,
+      configurable: false,
+      enumerable: true,
+      value: null
+    }
+  }));
   /* Decide if ARIA attributes are okay */
   let ALLOW_ARIA_ATTR = true;
   /* Decide if custom data attributes are okay */
@@ -11349,16 +11245,24 @@ function createDOMPurify() {
     }
     /* Merge configuration parameters */
     if (cfg.ADD_TAGS) {
-      if (ALLOWED_TAGS === DEFAULT_ALLOWED_TAGS) {
-        ALLOWED_TAGS = clone(ALLOWED_TAGS);
+      if (typeof cfg.ADD_TAGS === 'function') {
+        EXTRA_ELEMENT_HANDLING.tagCheck = cfg.ADD_TAGS;
+      } else {
+        if (ALLOWED_TAGS === DEFAULT_ALLOWED_TAGS) {
+          ALLOWED_TAGS = clone(ALLOWED_TAGS);
+        }
+        addToSet(ALLOWED_TAGS, cfg.ADD_TAGS, transformCaseFunc);
       }
-      addToSet(ALLOWED_TAGS, cfg.ADD_TAGS, transformCaseFunc);
     }
     if (cfg.ADD_ATTR) {
-      if (ALLOWED_ATTR === DEFAULT_ALLOWED_ATTR) {
-        ALLOWED_ATTR = clone(ALLOWED_ATTR);
+      if (typeof cfg.ADD_ATTR === 'function') {
+        EXTRA_ELEMENT_HANDLING.attributeCheck = cfg.ADD_ATTR;
+      } else {
+        if (ALLOWED_ATTR === DEFAULT_ALLOWED_ATTR) {
+          ALLOWED_ATTR = clone(ALLOWED_ATTR);
+        }
+        addToSet(ALLOWED_ATTR, cfg.ADD_ATTR, transformCaseFunc);
       }
-      addToSet(ALLOWED_ATTR, cfg.ADD_ATTR, transformCaseFunc);
     }
     if (cfg.ADD_URI_SAFE_ATTR) {
       addToSet(URI_SAFE_ATTRIBUTES, cfg.ADD_URI_SAFE_ATTR, transformCaseFunc);
@@ -11666,7 +11570,7 @@ function createDOMPurify() {
       return true;
     }
     /* Remove element if anything forbids its presence */
-    if (!ALLOWED_TAGS[tagName] || FORBID_TAGS[tagName]) {
+    if (!(EXTRA_ELEMENT_HANDLING.tagCheck instanceof Function && EXTRA_ELEMENT_HANDLING.tagCheck(tagName)) && (!ALLOWED_TAGS[tagName] || FORBID_TAGS[tagName])) {
       /* Check if we have a custom element to handle */
       if (!FORBID_TAGS[tagName] && _isBasicCustomElement(tagName)) {
         if (CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof RegExp && regExpTest(CUSTOM_ELEMENT_HANDLING.tagNameCheck, tagName)) {
@@ -11738,7 +11642,7 @@ function createDOMPurify() {
         (https://html.spec.whatwg.org/multipage/dom.html#embedding-custom-non-visible-data-with-the-data-*-attributes)
         XML-compatible (https://html.spec.whatwg.org/multipage/infrastructure.html#xml-compatible and http://www.w3.org/TR/xml/#d0e804)
         We don't need to check the value; it's always URI safe. */
-    if (ALLOW_DATA_ATTR && !FORBID_ATTR[lcName] && regExpTest(DATA_ATTR, lcName)) ; else if (ALLOW_ARIA_ATTR && regExpTest(ARIA_ATTR, lcName)) ; else if (!ALLOWED_ATTR[lcName] || FORBID_ATTR[lcName]) {
+    if (ALLOW_DATA_ATTR && !FORBID_ATTR[lcName] && regExpTest(DATA_ATTR, lcName)) ; else if (ALLOW_ARIA_ATTR && regExpTest(ARIA_ATTR, lcName)) ; else if (EXTRA_ELEMENT_HANDLING.attributeCheck instanceof Function && EXTRA_ELEMENT_HANDLING.attributeCheck(lcName, lcTag)) ; else if (!ALLOWED_ATTR[lcName] || FORBID_ATTR[lcName]) {
       if (
       // First condition does a very basic check if a) it's basically a valid custom element tagname AND
       // b) if the tagName passes whatever the user has configured for CUSTOM_ELEMENT_HANDLING.tagNameCheck
@@ -17145,7 +17049,7 @@ class TrackBase {
         } else if (isFile(config.url)) {
             this.name = config.url.name;
         } else if (isString$3(config.url) && !config.url.startsWith("data:")) {
-            this.name = getFilename$2(config.url);
+            this.name = getFilename$1(config.url);
         }
 
         this.url = config.url;
@@ -20664,6 +20568,7 @@ class FeatureFileReader {
 
         switch (config.format) {
             case "vcf":
+            case "vcftabix":
                 return new VcfParser(config)
             case "seg" :
                 return new SegParser("seg")
@@ -21104,7 +21009,7 @@ class HtsgetReader {
                 config.format = format.toLowerCase();
                 config.sourceType = "htsget";
                 if (!config.name) {
-                    config.name = await getFilename$1(config.url);
+                    config.name = getFilename$1(config.url);
                 }
             }
         } catch (e) {
@@ -21275,6 +21180,7 @@ class HtsgetVariantReader extends HtsgetReader {
     }
 }
 
+// Base class for feature sources.  Subclasses must implement getFeatures().
 class BaseFeatureSource {
 
     constructor(genome) {
@@ -21336,59 +21242,10 @@ class BaseFeatureSource {
         }
     }
 
-    async previousFeature(chr, position, direction, visibilityWindow) {
-
-        let chromosomeNames = this.genome.chromosomeNames || [chr];
-        let idx = chromosomeNames.indexOf(chr);
-        if (idx < 0) return // This shouldn't happen
-
-        // Look ahead (or behind) in 10 kb intervals, but no further than visibilityWindow
-        const window = Math.min(10000, visibilityWindow || 10000);
-        let queryStart = direction ? position : Math.max(position - window, 0);
-        while (idx < chromosomeNames.length && idx >= 0) {
-            chr = chromosomeNames[idx];
-            const chromosome = this.genome.getChromosome(chr);
-            const chromosomeEnd = chromosome.bpLength;
-            while (queryStart < chromosomeEnd && queryStart >= 0) {
-                let queryEnd = Math.min(position, queryStart + window);
-                const featureList = await this.getFeatures({chr, start: queryStart, end: queryEnd, visibilityWindow});
-                if (featureList) {
-
-                    const compare = (o1, o2) => o1.start - o2.start + o1.end - o2.end;
-                    const sortedList = Array.from(featureList);
-                    sortedList.sort(compare);
-
-                    // Search for next or previous feature relative to centers.  We use a linear search because the
-                    // feature is likely to be near the first or end of the list
-                    let idx = direction ? 0 : sortedList.length - 1;
-                    while(idx >= 0 && idx < sortedList.length) {
-                        const f = sortedList[idx];
-                        const center = (f.start + f.end) / 2;
-                        if(direction) {
-                            if(center > position) return f
-                            idx++;
-                        } else {
-                            if(center < position) return f
-                            idx--;
-                        }
-                    }
-                }
-                queryStart = direction ? queryEnd : queryStart - window;
-            }
-            if (direction) {
-                idx++;
-                queryStart = 0;
-                position = 0;
-            } else {
-                idx--;
-                if (idx < 0) break
-                const prevChromosome = this.genome.getChromosome(chromosomeNames[idx]);
-                position = prevChromosome.bpLength;
-                queryStart = position - window;
-            }
-        }
+    // Subclasses must implement
+    async getFeatures({chr, start, end, bpPerPixel, visibilityWindow}) {
+        throw new Error("getFeatures not implemented")
     }
-
 }
 
 const GZIP_FLAG = 0x1;
@@ -26527,6 +26384,88 @@ class GenbankFeatureSource extends BaseFeatureSource {
     }
 }
 
+/**
+ * A feature source for a "list" file.  A list file is a text file with two columns, chromosome and URL.  It was
+ * created for the 1KG genotype files, which are split by chromosome, and at the moment that is the only use case.
+ */
+
+class ListFeatureSource extends BaseFeatureSource {
+
+    constructor(config, genome) {
+        super(genome);
+        this.config = config;
+        this.featureSourceMap = null;
+        this.header = null;
+    }
+
+    async getHeader() {
+
+        if (!this.header) {
+
+            if (!this.featureSourceMap) {
+                await this.init();
+            }
+            // Return the header from the first feature source.  It is assumed that all sources have a common header.
+            const firstFS = this.featureSourceMap.values().next().value;
+            if (firstFS && firstFS.getHeader) {
+                this.header = firstFS.getHeader();
+            } else {
+                this.header = Promise.resolve(undefined);
+            }
+        }
+
+        return this.header
+
+    }
+
+    async getFeatures({chr, start, end, bpPerPixel, visibilityWindow}) {
+
+        if (!this.featureSourceMap) {
+            await this.init();
+        }
+        const fs = this.featureSourceMap.get(chr);
+        if (fs) {
+            return fs.getFeatures({chr, start, end, bpPerPixel, visibilityWindow})
+        } else {
+            return []
+        }
+    }
+
+    async init() {
+        this.featureSourceMap = new Map();
+
+        const options = buildOptions(this.config);
+        const data = await igvxhr.loadByteArray(this.config.url, options);
+        const dataWrapper = getDataWrapper(data);
+
+        let line;
+        while ((line = dataWrapper.nextLine()) !== undefined) {
+            const trimmed = line.trim();
+            if (!trimmed.startsWith('#')) {
+                const tokens = trimmed.split(/\s+/);
+                if (tokens.length > 1) {
+                    const chr = tokens[0];
+                    const path = tokens[1];
+                    const sourceConfig = Object.assign({}, this.config);
+                    sourceConfig.url = path;
+                    if (path.endsWith(".vcf.gz")) {
+                        sourceConfig.format = "vcf";
+                        sourceConfig.indexURL = path + ".tbi";
+                    }
+                    this.featureSourceMap.set(chr, FeatureSource(sourceConfig, this.genome));
+                }
+            }
+        }
+    }
+
+    supportWholeGenome() {
+        return false
+    }
+}
+
+// chrY	https://1000genomes.s3.amazonaws.com/release/20130502/ALL.chrY.phase3_integrated_v1b.20130502.genotypes.vcf.gz
+// chrX	https://1000genomes.s3.amazonaws.com/release/20130502/ALL.chrX.phase3_shapeit2_mvncall_integrated_v1b.20130502.genotypes.vcf.gz
+
 const bbFormats = new Set(['bigwig', 'bw', 'bigbed', 'bb', 'biginteract', 'biggenepred', 'bignarrowpeak']);
 
 function FeatureSource(config, genome) {
@@ -26541,6 +26480,9 @@ function FeatureSource(config, genome) {
         return new TDFSource(config, genome)
     } else if ("gbk" === format) {
         return new GenbankFeatureSource(config, genome)
+    } else if ("vcf.list" === format) {
+        // This is a text file with two columns:   <chr>  <url to vcf>
+        return new ListFeatureSource(config, genome)
     } else {
         return new TextFeatureSource(config, genome)
     }
@@ -30403,6 +30345,19 @@ const supportedTypes = new Set([
 const filterTracks = new Set(["cytoBandIdeo", "assembly", "gap", "gapOverlap", "allGaps",
     "cpgIslandExtUnmasked", "windowMasker"]);
 
+const vizModeMap = new Map([
+    ["pack", "EXPANDED"],
+    ["full", "EXPANDED"],
+    ["squish", "SQUISHED"],
+    ["dense", "COLLAPSED"]
+]);
+const typeFormatMap = new Map([
+    ["vcftabix", "vcf"],
+    ["vcfphasedtrio", "vcf"],
+    ["bigdbsnp", "bigbed"],
+    ["genepred", "refgene"]
+]);
+
 class TrackDbHub {
 
     constructor(trackStanzas, groupStanzas) {
@@ -30548,14 +30503,13 @@ class TrackDbHub {
      */
     #getTrackConfig(t) {
 
-        const format = t.format;
+        const format = typeFormatMap.get(t.format) || t.format;
 
         const config = {
             "id": t.getProperty("track"),
             "name": t.getProperty("shortLabel"),
             "format": format,
-            "url": t.getProperty("bigDataUrl"),
-            "displayMode": t.displayMode,
+            "url": t.getProperty("bigDataUrl")
         };
 
         if ("vcfTabix" === format) {
@@ -30605,9 +30559,14 @@ class TrackDbHub {
 
         }
         if (t.hasProperty("itemRgb")) ;
-        if ("hide" === t.getProperty("visibility")) {
-            // TODO -- this not supported yet
-            config.visible = false;
+        if(t.hasProperty("visibility")) {
+            if ("hide" === t.getProperty("visibility")) {
+                // TODO -- this not supported yet
+                config.visible = false;
+            }
+            else {
+                config.displayMode = vizModeMap.get(t.getProperty("visibility")) || "COLLAPSED";
+            }
         }
         if (t.hasProperty("url")) {
             config.infoURL = t.getProperty("url");
@@ -31585,7 +31544,7 @@ class TrackViewport extends Viewport {
 
         this.overlayElement.style.top = `-${contentTop}px`;
 
-        if(!this.checkZoomIn()) return;
+        if (!this.checkZoomIn()) return
 
         if (!this.canvas) {
             this.repaint();
@@ -32224,7 +32183,7 @@ class TrackViewport extends Viewport {
 
                         popupTimerID = setTimeout(() => {
 
-                                const content = this.getPopupContent(event);
+                                const content = this.handleTrackClick(event);
                                 if (content) {
 
                                     if (false === event.shiftKey) {
@@ -32389,7 +32348,7 @@ class TrackViewport extends Viewport {
 
     }
 
-    getPopupContent(event) {
+    handleTrackClick(event) {
 
         const clickState = this.createClickState(event);
 
@@ -37788,6 +37747,8 @@ function inferTrackType(format) {
             case "tdf":
                 return "wig"
             case "vcf":
+            case "vcftabix":
+            case "vcf.list":
                 return "variant"
             case "seg":
                 return "seg"
@@ -37842,7 +37803,7 @@ function translateDeprecatedTypes(config) {
     } else if ("bam" === config.type) {
         config.type = "alignment";
         config.format = "bam";
-    } else if ("vcf" === config.type) {
+    } else if ("vcf" === config.type || "vcftabix" === config.type) {
         config.type = "variant";
         config.format = "vcf";
     } else if ("t2d" === config.type) {
@@ -38122,7 +38083,7 @@ class SegTrack extends TrackBase {
         const groupIndeces = NULL_GROUP !== this.groupBy ?
             this.sampleKeys.map(sample => this.getGroupIndex(sample)) : undefined;
         return {
-            names: this.sampleKeys,
+            names: this.sampleKeys || [],
             height: this.sampleHeight,
             yOffset: 0,
             groups: this.groups,
@@ -42535,7 +42496,7 @@ async function inferFileFormat(config) {
     let format;
 
     // First try determining format from file extension
-    const filename = config.filename || await getFilename$1(config.url);
+    const filename = config.filename || getFilename$1(config.url);
     if(filename) {
         format = await inferFileFormatFromName(filename);
     }
@@ -62819,7 +62780,8 @@ class VariantTrack extends TrackBase {
     }
 
     get supportsWholeGenome() {
-        return !this.config.indexURL || this.config.supportsWholeGenome === true
+        const sourceSupportsWG = typeof this.featureSource.supportsWholeGenome === 'function' && this.featureSource.supportsWholeGenome();
+        return sourceSupportsWG || this.config.supportsWholeGenome === true
     }
 
     get color() {
@@ -62892,7 +62854,7 @@ class VariantTrack extends TrackBase {
         const yOffset = TOP_MARGIN + nVariantRows * (variantHeight + vGap);
 
         return {
-            names: this.sampleKeys,
+            names: this.sampleKeys || [],
             yOffset,
             height,
             // groups: this.groups,
@@ -67023,7 +66985,7 @@ function createReferenceFrameList(loci, genome, browserFlanking, minimumBases, v
     })
 }
 
-const _version = "3.5.2";
+const _version = "3.5.4";
 function version() {
     return _version
 }
@@ -68927,7 +68889,7 @@ class ROIManager {
 
         for (let config of configs) {
             if (!config.name && config.url) {
-                config.name = await getFilename$1(config.url);
+                config.name = getFilename$1(config.url);
             }
             if (config.url && !config.format) {
                 config.format = await inferFileFormat(config);
@@ -73714,7 +73676,8 @@ class EventEmitter {
             return handler.apply(scope, args)
         });
 
-        return results
+        // The only event that uses the return value is "trackclick", which implicitly assumes a single handler
+        return results[0]
     }
 }
 
@@ -74085,7 +74048,7 @@ class Browser {
         } else {
             let filename = options.filename;
             if (!filename) {
-                filename = (options.url ? await getFilename$1(options.url) : options.file.name);
+                filename = (options.url ? getFilename$1(options.url) : options.file.name);
             }
 
             if (filename.endsWith(".xml")) {
@@ -74099,10 +74062,8 @@ class Browser {
                 config = {
                     reference: genomeConfig
                 };
-            } else if (filename.endsWith(".json")) {
+            } else  {
                 config = await igvxhr.loadJson(urlOrFile);
-            } else {
-                throw Error("Unrecognized session file format:" + filename)
             }
         }
         setDefaults(config, defaults);
@@ -74570,6 +74531,10 @@ class Browser {
             config = JSON.parse(config);
         }
 
+        if(config.format && config.format.toLowerCase() === 'sampleinfo') {
+            return this.loadSampleInfo(config)
+        }
+
         let track;
         try {
             track = await this.createTrack(config);
@@ -76346,6 +76311,10 @@ function setOauthToken(accessToken, host) {
     return igvxhr.setOauthToken(accessToken, host)
 }
 
+function setCORSProxy(proxyURL) {
+    igvxhr.corsProxy = proxyURL;
+}
+
 // Backward compatibility
 const oauth = igvxhr.oauth;
 
@@ -76362,6 +76331,7 @@ var index = {
     visibilityChange,
     setGoogleOauthToken,
     setOauthToken,
+    setCORSProxy,
     oauth,
     version,
     setApiKey,