igv 3.5.2 → 3.5.4

package/dist/igv.js

@@ -392,12 +392,12 @@
            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)
    };
 
 
@@ -425,24 +425,24 @@
                }
            }
        }
-       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
    }
 
 
@@ -466,7 +466,7 @@
            range.end = range.start + 1;
        }
 
-       return range;
+       return range
    }
 
    /**
@@ -475,7 +475,7 @@
     * @param urlOrFile
     */
 
-   function getFilename$2(urlOrFile) {
+   function getFilename$1(urlOrFile) {
 
        if (urlOrFile.name !== undefined) {
            return urlOrFile.name
@@ -502,8 +502,8 @@
     * @param object
     */
    function isFile(object) {
-       if(!object) {
-           return false;
+       if (!object) {
+           return false
        }
        return typeof object !== 'function' &&
            (object instanceof File ||
@@ -523,7 +523,7 @@
 
    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')
        };
    }
 
@@ -542,7 +542,7 @@
            if ($1) uri[o.q.name][$1] = $2;
        });
 
-       return uri;
+       return uri
    }
 
    const options = {
@@ -565,7 +565,7 @@
     * @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) */
@@ -7427,7 +7427,7 @@
 
    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
    }
 
    /**
@@ -7437,9 +7437,9 @@
        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)
        }
    }
 
@@ -7465,7 +7465,7 @@
                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);
@@ -7478,13 +7478,13 @@
                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;
@@ -7493,14 +7493,14 @@
                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
@@ -7510,12 +7510,12 @@
 
    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);
@@ -7552,7 +7552,7 @@
        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
    }
 
    /**
@@ -7577,7 +7577,7 @@
        for (let b of bytes) {
            str += String.fromCharCode(b);
        }
-       return str;
+       return str
    }
 
 
@@ -7607,7 +7607,7 @@
            }
            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
        }
    }
 
@@ -7639,7 +7639,7 @@
    const IGVMath = {
 
        lerp: (v0, v1, t) => {
-           return (1 - t) * v0 + t * v1;
+           return (1 - t) * v0 + t * v1
        },
 
        mean: function (array) {
@@ -7652,7 +7652,7 @@
                    n++;
                }
            }
-           return n > 0 ? t / n : 0;
+           return n > 0 ? t / n : 0
        },
 
        meanAndStdev: function (array) {
@@ -7669,7 +7669,7 @@
                    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) {
@@ -7687,33 +7687,33 @@
                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
        }
 
    };
@@ -7739,7 +7739,7 @@
            }
        }
 
-       return heap.content[0];
+       return heap.content[0]
    }
 
 
@@ -7766,7 +7766,7 @@
                this.content[0] = end;
                this.sinkDown(0);
            }
-           return result;
+           return result
        },
 
        remove: function (node) {
@@ -7774,24 +7774,24 @@
            // 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) {
@@ -7805,7 +7805,7 @@
                // 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.
@@ -7845,7 +7845,7 @@
                }
 
                // 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];
@@ -8439,145 +8439,78 @@
    }
 
    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.
 
@@ -8608,7 +8541,8 @@
        // Attach an object to keep igv state
        google.igv = {
            tokenClient: tokenClient,
-           apiKey: config.apiKey
+           apiKey: config.apiKey,
+           appId: config.appId
        };
    }
 
@@ -8628,8 +8562,6 @@
            undefined
    }
 
-
-   let promise;
    /**
     * Return a promise for an access token for the given scope.  If the user hasn't authorized the scope request it
     *
@@ -8648,27 +8580,21 @@
            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);
+               }
+           })
        }
    }
 
@@ -8687,90 +8613,6 @@
        }
    }
 
-   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)
 
    /**
@@ -8802,7 +8644,7 @@
                    asyncFunction: asyncFunction,
                });
                self.dequeue();
-           });
+           })
        }
 
        /**
@@ -8815,10 +8657,10 @@
         */
        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)
        };
 
        /**
@@ -8890,6 +8732,10 @@
 
    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({
@@ -8897,6 +8743,7 @@
            });
            this.RANGE_WARNING_GIVEN = false;
            this.oauth = new Oauth();
+           this.corsProxy = undefined;
        }
 
        setApiKey(key) {
@@ -8921,7 +8768,7 @@
         * @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)) {
@@ -8966,7 +8813,7 @@
 
            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) {
@@ -8976,9 +8823,6 @@
                        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)
@@ -8996,14 +8840,21 @@
 
            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) {
@@ -9076,8 +8927,10 @@
 
                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'];
@@ -9093,7 +8946,7 @@
                                // 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));
@@ -9110,20 +8963,29 @@
                        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);
                    }
                };
 
@@ -9155,6 +9017,27 @@
                    }
                }
 
+               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);
@@ -9173,6 +9056,8 @@
                        }
                    }
                }
+
+
            })
 
        }
@@ -9245,20 +9130,29 @@
        }
 
        /**
-        * 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
+               }
+           }
        }
 
    }
@@ -9321,8 +9215,10 @@
    }
 
    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";
@@ -9337,8 +9233,6 @@
 
        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")) {
@@ -9534,17 +9428,17 @@
 
            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
        }
 
        /**
@@ -9629,7 +9523,7 @@
            searchAll$1.call(this, interval, node.right, results);
        }
 
-       return results;
+       return results
    }
 
    function leftRotate$1(x) {
@@ -9708,35 +9602,35 @@
 
        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)
        }
    }
 
@@ -9781,19 +9675,19 @@
            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 {
 
@@ -9846,7 +9740,7 @@
                        } // while (bucket)
 
                        if (!bucket) {
-                           break;
+                           break
                        }
                        feature = bucket.pop();
                        if (0 === bucket.length) {
@@ -9863,7 +9757,7 @@
                    row++;
                    nextStart = bucketStart;
 
-                   if (allocatedCount === lastAllocatedCount) break;   // Protect from infinite loops
+                   if (allocatedCount === lastAllocatedCount) break   // Protect from infinite loops
 
                    lastAllocatedCount = allocatedCount;
 
@@ -9885,13 +9779,13 @@
        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.
@@ -9904,7 +9798,7 @@
                        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);
                            }
@@ -9912,10 +9806,10 @@
                    });
 
                    featureList.sort(function (a, b) {
-                       return a.start - b.start;
+                       return a.start - b.start
                    });
 
-                   return featureList;
+                   return featureList
                }
            }
 
@@ -9936,7 +9830,7 @@
        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) {
@@ -9950,7 +9844,7 @@
            tree.insert(iStart, iEnd, subArray);
        }
 
-       return tree;
+       return tree
    }
 
    function hexToRGB(hex) {
@@ -10401,7 +10295,7 @@
            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);
@@ -10475,19 +10369,6 @@
        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,
@@ -10550,12 +10431,12 @@
        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 {
@@ -10745,7 +10626,7 @@
        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,
@@ -10931,7 +10812,7 @@
    }
 
    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
@@ -10945,7 +10826,7 @@
    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']);
 
@@ -11052,7 +10933,7 @@
    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
@@ -11163,6 +11044,21 @@
      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 */
@@ -11355,16 +11251,24 @@
        }
        /* 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);
@@ -11672,7 +11576,7 @@
          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)) {
@@ -11744,7 +11648,7 @@
            (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
@@ -17151,7 +17055,7 @@
            } 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;
@@ -20670,6 +20574,7 @@
 
            switch (config.format) {
                case "vcf":
+               case "vcftabix":
                    return new VcfParser(config)
                case "seg" :
                    return new SegParser("seg")
@@ -21110,7 +21015,7 @@
                    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) {
@@ -21281,6 +21186,7 @@
        }
    }
 
+   // Base class for feature sources.  Subclasses must implement getFeatures().
    class BaseFeatureSource {
 
        constructor(genome) {
@@ -21342,59 +21248,10 @@
            }
        }
 
-       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;
@@ -26533,6 +26390,88 @@
        }
    }
 
+   /**
+    * 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) {
@@ -26547,6 +26486,9 @@
            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)
        }
@@ -30409,6 +30351,19 @@
    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) {
@@ -30554,14 +30509,13 @@
         */
        #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) {
@@ -30611,9 +30565,14 @@
 
            }
            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");
@@ -31591,7 +31550,7 @@
 
            this.overlayElement.style.top = `-${contentTop}px`;
 
-           if(!this.checkZoomIn()) return;
+           if (!this.checkZoomIn()) return
 
            if (!this.canvas) {
                this.repaint();
@@ -32230,7 +32189,7 @@
 
                            popupTimerID = setTimeout(() => {
 
-                                   const content = this.getPopupContent(event);
+                                   const content = this.handleTrackClick(event);
                                    if (content) {
 
                                        if (false === event.shiftKey) {
@@ -32395,7 +32354,7 @@
 
        }
 
-       getPopupContent(event) {
+       handleTrackClick(event) {
 
            const clickState = this.createClickState(event);
 
@@ -37794,6 +37753,8 @@
                case "tdf":
                    return "wig"
                case "vcf":
+               case "vcftabix":
+               case "vcf.list":
                    return "variant"
                case "seg":
                    return "seg"
@@ -37848,7 +37809,7 @@
        } 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) {
@@ -38128,7 +38089,7 @@
            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,
@@ -42541,7 +42502,7 @@
        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);
        }
@@ -62825,7 +62786,8 @@ ${indent}columns: ${matrix.columns}
        }
 
        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() {
@@ -62898,7 +62860,7 @@ ${indent}columns: ${matrix.columns}
            const yOffset = TOP_MARGIN + nVariantRows * (variantHeight + vGap);
 
            return {
-               names: this.sampleKeys,
+               names: this.sampleKeys || [],
                yOffset,
                height,
                // groups: this.groups,
@@ -67029,7 +66991,7 @@ ${indent}columns: ${matrix.columns}
        })
    }
 
-   const _version = "3.5.2";
+   const _version = "3.5.4";
    function version() {
        return _version
    }
@@ -68933,7 +68895,7 @@ ${indent}columns: ${matrix.columns}
 
            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);
@@ -73720,7 +73682,8 @@ ${indent}columns: ${matrix.columns}
                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]
        }
    }
 
@@ -74091,7 +74054,7 @@ ${indent}columns: ${matrix.columns}
            } 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")) {
@@ -74105,10 +74068,8 @@ ${indent}columns: ${matrix.columns}
                    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);
@@ -74576,6 +74537,10 @@ ${indent}columns: ${matrix.columns}
                config = JSON.parse(config);
            }
 
+           if(config.format && config.format.toLowerCase() === 'sampleinfo') {
+               return this.loadSampleInfo(config)
+           }
+
            let track;
            try {
                track = await this.createTrack(config);
@@ -76352,6 +76317,10 @@ ${indent}columns: ${matrix.columns}
        return igvxhr.setOauthToken(accessToken, host)
    }
 
+   function setCORSProxy(proxyURL) {
+       igvxhr.corsProxy = proxyURL;
+   }
+
    // Backward compatibility
    const oauth = igvxhr.oauth;
 
@@ -76368,6 +76337,7 @@ ${indent}columns: ${matrix.columns}
        visibilityChange,
        setGoogleOauthToken,
        setOauthToken,
+       setCORSProxy,
        oauth,
        version,
        setApiKey,