diff --git a/public/cy_custom.js b/public/cy_custom.js
new file mode 100644
index 0000000..a1efed8
--- /dev/null
+++ b/public/cy_custom.js
@@ -0,0 +1,65 @@
+(function () {
+    const EXTREME_ZOOM_MIN = 1e-4;
+    const EXTREME_ZOOM_MAX = 1e4;
+  
+    function applyCustomZoomHandling(cy) {
+      let zoomFramePending = false;
+  
+      if (!cy || typeof cy.zoom !== 'function') {
+        console.warn('🚫 유효하지 않은 Cytoscape 인스턴스입니다.');
+        return;
+      }
+  
+      cy.userZoomingEnabled(false); // Cytoscape 기본 줌 비활성화
+  
+      const container = cy.container();
+      if (!container) {
+        console.warn('🚫 Cytoscape container를 찾을 수 없습니다.');
+        return;
+      }
+  
+      container.addEventListener(
+        'wheel',
+        (event) => {
+          event.preventDefault();
+  
+          if (zoomFramePending) return;
+          zoomFramePending = true;
+  
+          requestAnimationFrame(() => {
+            const currentZoom = cy.zoom();
+  
+            const clampedDelta = Math.max(-100, Math.min(100, event.deltaY));
+            const zoomFactor = 1 + (clampedDelta > 0 ? -0.05 : 0.05);
+            const nextZoom = currentZoom * zoomFactor;
+  
+            const isValid =
+              isFinite(nextZoom) &&
+              nextZoom >= EXTREME_ZOOM_MIN &&
+              nextZoom <= EXTREME_ZOOM_MAX;
+  
+            if (isValid) {
+              const rect = container.getBoundingClientRect();
+              const renderedPosition = {
+                x: event.clientX - rect.left,
+                y: event.clientY - rect.top
+              };
+              cy.zoom({
+                level: nextZoom,
+                renderedPosition
+              });
+            } else {
+              console.warn("🚫 휠 줌 비정상 값 차단:", nextZoom);
+            }
+  
+            zoomFramePending = false;
+          });
+        },
+        { passive: false }
+      );
+    }
+  
+    // ✅ 전역(window)으로 함수 등록
+    window.applyCustomZoomHandling = applyCustomZoomHandling;
+  })();
+  
\ No newline at end of file
diff --git a/public/igv.css b/public/igv.css
new file mode 100644
index 0000000..8f89c40
--- /dev/null
+++ b/public/igv.css
@@ -0,0 +1,28 @@
+/* IGV blue lines & UI custom style (기본 파란색: #3579f6) */
+.igv-blue-line {
+  background: #3579f6 !important;
+  width: 2px !important;
+  z-index: 1000;
+}
+.igv-blue-fill {
+  background: rgba(53, 121, 246, 0.18) !important;
+  z-index: 999;
+}
+.igv-control-btn {
+  background: #f5faff;
+  color: #3579f6;
+  border: 1.5px solid #3579f6;
+  border-radius: 5px;
+  padding: 6px 16px;
+  font-size: 15px;
+  cursor: pointer;
+  transition: background 0.2s, border 0.2s, color 0.2s;
+}
+.igv-control-btn:hover {
+  background: #3579f6;
+  color: #fff;
+  border: 2px solid #2456a6;
+}
+.igv-blue-line.selected {
+  box-shadow: 0 0 8px #3579f6;
+} 
\ No newline at end of file
diff --git a/public/igv.js b/public/igv.js
new file mode 100644
index 0000000..e58285f
--- /dev/null
+++ b/public/igv.js
@@ -0,0 +1,67298 @@
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
+    typeof define === 'function' && define.amd ? define(factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.igv = factory());
+}(this, (function () { 'use strict';
+
+    /*!
+     * jQuery JavaScript Library v3.3.1 -ajax,-ajax/jsonp,-ajax/load,-ajax/parseXML,-ajax/script,-ajax/var/location,-ajax/var/nonce,-ajax/var/rquery,-ajax/xhr,-manipulation/_evalUrl,-event/ajax,-effects,-effects/Tween,-effects/animatedSelector
+     * https://jquery.com/
+     *
+     * Includes Sizzle.js
+     * https://sizzlejs.com/
+     *
+     * Copyright JS Foundation and other contributors
+     * Released under the MIT license
+     * https://jquery.org/license
+     *
+     * Date: 2018-01-20T17:24Z
+     */
+
+    var arr = [];
+    var document$2 = window.document;
+    var getProto = Object.getPrototypeOf;
+    var slice = arr.slice;
+    var concat = arr.concat;
+    var push = arr.push;
+    var indexOf$1 = arr.indexOf;
+    var class2type = {};
+    var toString$1 = class2type.toString;
+    var hasOwn = class2type.hasOwnProperty;
+    var fnToString = hasOwn.toString;
+    var ObjectFunctionString = fnToString.call(Object);
+    var support = {};
+
+    var isFunction = function isFunction(obj) {
+      // Support: Chrome <=57, Firefox <=52
+      // In some browsers, typeof returns "function" for HTML <object> elements
+      // (i.e., `typeof document.createElement( "object" ) === "function"`).
+      // We don't want to classify *any* DOM node as a function.
+      return typeof obj === "function" && typeof obj.nodeType !== "number";
+    };
+
+    var isWindow = function isWindow(obj) {
+      return obj != null && obj === obj.window;
+    };
+
+    var preservedScriptAttributes = {
+      type: true,
+      src: true,
+      noModule: true
+    };
+
+    function DOMEval(code, doc, node) {
+      doc = doc || document$2;
+      var i,
+          script = doc.createElement("script");
+      script.text = code;
+
+      if (node) {
+        for (i in preservedScriptAttributes) {
+          if (node[i]) {
+            script[i] = node[i];
+          }
+        }
+      }
+
+      doc.head.appendChild(script).parentNode.removeChild(script);
+    }
+
+    function toType(obj) {
+      if (obj == null) {
+        return obj + "";
+      } // Support: Android <=2.3 only (functionish RegExp)
+
+
+      return typeof obj === "object" || typeof obj === "function" ? class2type[toString$1.call(obj)] || "object" : typeof obj;
+    } // global Symbol
+    // Defining this global in .eslintrc.json would create a danger of using the global
+    // unguarded in another place, it seems safer to define global only for this module
+
+
+    var version$2 = "3.3.1 -ajax,-ajax/jsonp,-ajax/load,-ajax/parseXML,-ajax/script,-ajax/var/location,-ajax/var/nonce,-ajax/var/rquery,-ajax/xhr,-manipulation/_evalUrl,-event/ajax,-effects,-effects/Tween,-effects/animatedSelector",
+        // Define a local copy of jQuery
+    jQuery = function (selector, context) {
+      // The jQuery object is actually just the init constructor 'enhanced'
+      // Need init if jQuery is called (just allow error to be thrown if not included)
+      return new jQuery.fn.init(selector, context);
+    },
+        // Support: Android <=4.0 only
+    // Make sure we trim BOM and NBSP
+    rtrim = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g;
+
+    jQuery.fn = jQuery.prototype = {
+      // The current version of jQuery being used
+      jquery: version$2,
+      constructor: jQuery,
+      // The default length of a jQuery object is 0
+      length: 0,
+      toArray: function () {
+        return slice.call(this);
+      },
+      // Get the Nth element in the matched element set OR
+      // Get the whole matched element set as a clean array
+      get: function (num) {
+        // Return all the elements in a clean array
+        if (num == null) {
+          return slice.call(this);
+        } // Return just the one element from the set
+
+
+        return num < 0 ? this[num + this.length] : this[num];
+      },
+      // Take an array of elements and push it onto the stack
+      // (returning the new matched element set)
+      pushStack: function (elems) {
+        // Build a new jQuery matched element set
+        var ret = jQuery.merge(this.constructor(), elems); // Add the old object onto the stack (as a reference)
+
+        ret.prevObject = this; // Return the newly-formed element set
+
+        return ret;
+      },
+      // Execute a callback for every element in the matched set.
+      each: function (callback) {
+        return jQuery.each(this, callback);
+      },
+      map: function (callback) {
+        return this.pushStack(jQuery.map(this, function (elem, i) {
+          return callback.call(elem, i, elem);
+        }));
+      },
+      slice: function () {
+        return this.pushStack(slice.apply(this, arguments));
+      },
+      first: function () {
+        return this.eq(0);
+      },
+      last: function () {
+        return this.eq(-1);
+      },
+      eq: function (i) {
+        var len = this.length,
+            j = +i + (i < 0 ? len : 0);
+        return this.pushStack(j >= 0 && j < len ? [this[j]] : []);
+      },
+      end: function () {
+        return this.prevObject || this.constructor();
+      },
+      // For internal use only.
+      // Behaves like an Array's method, not like a jQuery method.
+      push: push,
+      sort: arr.sort,
+      splice: arr.splice
+    };
+
+    jQuery.extend = jQuery.fn.extend = function () {
+      var options,
+          name,
+          src,
+          copy,
+          copyIsArray,
+          clone,
+          target = arguments[0] || {},
+          i = 1,
+          length = arguments.length,
+          deep = false; // Handle a deep copy situation
+
+      if (typeof target === "boolean") {
+        deep = target; // Skip the boolean and the target
+
+        target = arguments[i] || {};
+        i++;
+      } // Handle case when target is a string or something (possible in deep copy)
+
+
+      if (typeof target !== "object" && !isFunction(target)) {
+        target = {};
+      } // Extend jQuery itself if only one argument is passed
+
+
+      if (i === length) {
+        target = this;
+        i--;
+      }
+
+      for (; i < length; i++) {
+        // Only deal with non-null/undefined values
+        if ((options = arguments[i]) != null) {
+          // Extend the base object
+          for (name in options) {
+            src = target[name];
+            copy = options[name]; // Prevent never-ending loop
+
+            if (target === copy) {
+              continue;
+            } // Recurse if we're merging plain objects or arrays
+
+
+            if (deep && copy && (jQuery.isPlainObject(copy) || (copyIsArray = Array.isArray(copy)))) {
+              if (copyIsArray) {
+                copyIsArray = false;
+                clone = src && Array.isArray(src) ? src : [];
+              } else {
+                clone = src && jQuery.isPlainObject(src) ? src : {};
+              } // Never move original objects, clone them
+
+
+              target[name] = jQuery.extend(deep, clone, copy); // Don't bring in undefined values
+            } else if (copy !== undefined) {
+              target[name] = copy;
+            }
+          }
+        }
+      } // Return the modified object
+
+
+      return target;
+    };
+
+    jQuery.extend({
+      // Unique for each copy of jQuery on the page
+      expando: "jQuery" + (version$2 + Math.random()).replace(/\D/g, ""),
+      // Assume jQuery is ready without the ready module
+      isReady: true,
+      error: function (msg) {
+        throw new Error(msg);
+      },
+      noop: function () {},
+      isPlainObject: function (obj) {
+        var proto, Ctor; // Detect obvious negatives
+        // Use toString instead of jQuery.type to catch host objects
+
+        if (!obj || toString$1.call(obj) !== "[object Object]") {
+          return false;
+        }
+
+        proto = getProto(obj); // Objects with no prototype (e.g., `Object.create( null )`) are plain
+
+        if (!proto) {
+          return true;
+        } // Objects with prototype are plain iff they were constructed by a global Object function
+
+
+        Ctor = hasOwn.call(proto, "constructor") && proto.constructor;
+        return typeof Ctor === "function" && fnToString.call(Ctor) === ObjectFunctionString;
+      },
+      isEmptyObject: function (obj) {
+        /* eslint-disable no-unused-vars */
+        // See https://github.com/eslint/eslint/issues/6125
+        var name;
+
+        for (name in obj) {
+          return false;
+        }
+
+        return true;
+      },
+      // Evaluates a script in a global context
+      globalEval: function (code) {
+        DOMEval(code);
+      },
+      each: function (obj, callback) {
+        var length,
+            i = 0;
+
+        if (isArrayLike(obj)) {
+          length = obj.length;
+
+          for (; i < length; i++) {
+            if (callback.call(obj[i], i, obj[i]) === false) {
+              break;
+            }
+          }
+        } else {
+          for (i in obj) {
+            if (callback.call(obj[i], i, obj[i]) === false) {
+              break;
+            }
+          }
+        }
+
+        return obj;
+      },
+      // Support: Android <=4.0 only
+      trim: function (text) {
+        return text == null ? "" : (text + "").replace(rtrim, "");
+      },
+      // results is for internal usage only
+      makeArray: function (arr, results) {
+        var ret = results || [];
+
+        if (arr != null) {
+          if (isArrayLike(Object(arr))) {
+            jQuery.merge(ret, typeof arr === "string" ? [arr] : arr);
+          } else {
+            push.call(ret, arr);
+          }
+        }
+
+        return ret;
+      },
+      inArray: function (elem, arr, i) {
+        return arr == null ? -1 : indexOf$1.call(arr, elem, i);
+      },
+      // Support: Android <=4.0 only, PhantomJS 1 only
+      // push.apply(_, arraylike) throws on ancient WebKit
+      merge: function (first, second) {
+        var len = +second.length,
+            j = 0,
+            i = first.length;
+
+        for (; j < len; j++) {
+          first[i++] = second[j];
+        }
+
+        first.length = i;
+        return first;
+      },
+      grep: function (elems, callback, invert) {
+        var callbackInverse,
+            matches = [],
+            i = 0,
+            length = elems.length,
+            callbackExpect = !invert; // Go through the array, only saving the items
+        // that pass the validator function
+
+        for (; i < length; i++) {
+          callbackInverse = !callback(elems[i], i);
+
+          if (callbackInverse !== callbackExpect) {
+            matches.push(elems[i]);
+          }
+        }
+
+        return matches;
+      },
+      // arg is for internal usage only
+      map: function (elems, callback, arg) {
+        var length,
+            value,
+            i = 0,
+            ret = []; // Go through the array, translating each of the items to their new values
+
+        if (isArrayLike(elems)) {
+          length = elems.length;
+
+          for (; i < length; i++) {
+            value = callback(elems[i], i, arg);
+
+            if (value != null) {
+              ret.push(value);
+            }
+          } // Go through every key on the object,
+
+        } else {
+          for (i in elems) {
+            value = callback(elems[i], i, arg);
+
+            if (value != null) {
+              ret.push(value);
+            }
+          }
+        } // Flatten any nested arrays
+
+
+        return concat.apply([], ret);
+      },
+      // A global GUID counter for objects
+      guid: 1,
+      // jQuery.support is not used in Core but other projects attach their
+      // properties to it so it needs to exist.
+      support: support
+    });
+
+    if (typeof Symbol === "function") {
+      jQuery.fn[Symbol.iterator] = arr[Symbol.iterator];
+    } // Populate the class2type map
+
+
+    jQuery.each("Boolean Number String Function Array Date RegExp Object Error Symbol".split(" "), function (i, name) {
+      class2type["[object " + name + "]"] = name.toLowerCase();
+    });
+
+    function isArrayLike(obj) {
+      // Support: real iOS 8.2 only (not reproducible in simulator)
+      // `in` check used to prevent JIT error (gh-2145)
+      // hasOwn isn't used here due to false negatives
+      // regarding Nodelist length in IE
+      var length = !!obj && "length" in obj && obj.length,
+          type = toType(obj);
+
+      if (isFunction(obj) || isWindow(obj)) {
+        return false;
+      }
+
+      return type === "array" || length === 0 || typeof length === "number" && length > 0 && length - 1 in obj;
+    }
+
+    var Sizzle =
+    /*!
+    * Sizzle CSS Selector Engine v2.3.3
+    * https://sizzlejs.com/
+    *
+    * Copyright jQuery Foundation and other contributors
+    * Released under the MIT license
+    * http://jquery.org/license
+    *
+    * Date: 2016-08-08
+    */
+    function (window) {
+      var i,
+          support,
+          Expr,
+          getText,
+          isXML,
+          tokenize,
+          compile,
+          select,
+          outermostContext,
+          sortInput,
+          hasDuplicate,
+          // Local document vars
+      setDocument,
+          document,
+          docElem,
+          documentIsHTML,
+          rbuggyQSA,
+          rbuggyMatches,
+          matches,
+          contains,
+          // Instance-specific data
+      expando = "sizzle" + 1 * new Date(),
+          preferredDoc = window.document,
+          dirruns = 0,
+          done = 0,
+          classCache = createCache(),
+          tokenCache = createCache(),
+          compilerCache = createCache(),
+          sortOrder = function (a, b) {
+        if (a === b) {
+          hasDuplicate = true;
+        }
+
+        return 0;
+      },
+          // Instance methods
+      hasOwn = {}.hasOwnProperty,
+          arr = [],
+          pop = arr.pop,
+          push_native = arr.push,
+          push = arr.push,
+          slice = arr.slice,
+          // Use a stripped-down indexOf as it's faster than native
+      // https://jsperf.com/thor-indexof-vs-for/5
+      indexOf = function (list, elem) {
+        var i = 0,
+            len = list.length;
+
+        for (; i < len; i++) {
+          if (list[i] === elem) {
+            return i;
+          }
+        }
+
+        return -1;
+      },
+          booleans = "checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped",
+          // Regular expressions
+      // http://www.w3.org/TR/css3-selectors/#whitespace
+      whitespace = "[\\x20\\t\\r\\n\\f]",
+          // http://www.w3.org/TR/CSS21/syndata.html#value-def-identifier
+      identifier = "(?:\\\\.|[\\w-]|[^\0-\\xa0])+",
+          // Attribute selectors: http://www.w3.org/TR/selectors/#attribute-selectors
+      attributes = "\\[" + whitespace + "*(" + identifier + ")(?:" + whitespace + // Operator (capture 2)
+      "*([*^$|!~]?=)" + whitespace + // "Attribute values must be CSS identifiers [capture 5] or strings [capture 3 or capture 4]"
+      "*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|(" + identifier + "))|)" + whitespace + "*\\]",
+          pseudos = ":(" + identifier + ")(?:\\((" + // To reduce the number of selectors needing tokenize in the preFilter, prefer arguments:
+      // 1. quoted (capture 3; capture 4 or capture 5)
+      "('((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\")|" + // 2. simple (capture 6)
+      "((?:\\\\.|[^\\\\()[\\]]|" + attributes + ")*)|" + // 3. anything else (capture 2)
+      ".*" + ")\\)|)",
+          // Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter
+      rwhitespace = new RegExp(whitespace + "+", "g"),
+          rtrim = new RegExp("^" + whitespace + "+|((?:^|[^\\\\])(?:\\\\.)*)" + whitespace + "+$", "g"),
+          rcomma = new RegExp("^" + whitespace + "*," + whitespace + "*"),
+          rcombinators = new RegExp("^" + whitespace + "*([>+~]|" + whitespace + ")" + whitespace + "*"),
+          rattributeQuotes = new RegExp("=" + whitespace + "*([^\\]'\"]*?)" + whitespace + "*\\]", "g"),
+          rpseudo = new RegExp(pseudos),
+          ridentifier = new RegExp("^" + identifier + "$"),
+          matchExpr = {
+        "ID": new RegExp("^#(" + identifier + ")"),
+        "CLASS": new RegExp("^\\.(" + identifier + ")"),
+        "TAG": new RegExp("^(" + identifier + "|[*])"),
+        "ATTR": new RegExp("^" + attributes),
+        "PSEUDO": new RegExp("^" + pseudos),
+        "CHILD": new RegExp("^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\(" + whitespace + "*(even|odd|(([+-]|)(\\d*)n|)" + whitespace + "*(?:([+-]|)" + whitespace + "*(\\d+)|))" + whitespace + "*\\)|)", "i"),
+        "bool": new RegExp("^(?:" + booleans + ")$", "i"),
+        // For use in libraries implementing .is()
+        // We use this for POS matching in `select`
+        "needsContext": new RegExp("^" + whitespace + "*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\(" + whitespace + "*((?:-\\d)?\\d*)" + whitespace + "*\\)|)(?=[^-]|$)", "i")
+      },
+          rinputs = /^(?:input|select|textarea|button)$/i,
+          rheader = /^h\d$/i,
+          rnative = /^[^{]+\{\s*\[native \w/,
+          // Easily-parseable/retrievable ID or TAG or CLASS selectors
+      rquickExpr = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,
+          rsibling = /[+~]/,
+          // CSS escapes
+      // http://www.w3.org/TR/CSS21/syndata.html#escaped-characters
+      runescape = new RegExp("\\\\([\\da-f]{1,6}" + whitespace + "?|(" + whitespace + ")|.)", "ig"),
+          funescape = function (_, escaped, escapedWhitespace) {
+        var high = "0x" + escaped - 0x10000; // NaN means non-codepoint
+        // Support: Firefox<24
+        // Workaround erroneous numeric interpretation of +"0x"
+
+        return high !== high || escapedWhitespace ? escaped : high < 0 ? // BMP codepoint
+        String.fromCharCode(high + 0x10000) : // Supplemental Plane codepoint (surrogate pair)
+        String.fromCharCode(high >> 10 | 0xD800, high & 0x3FF | 0xDC00);
+      },
+          // CSS string/identifier serialization
+      // https://drafts.csswg.org/cssom/#common-serializing-idioms
+      // eslint-disable-next-line no-control-regex
+      rcssescape = /([\0-\x1f\x7f]|^-?\d)|^-$|[^\0-\x1f\x7f-\uFFFF\w-]/g,
+          fcssescape = function (ch, asCodePoint) {
+        if (asCodePoint) {
+          // U+0000 NULL becomes U+FFFD REPLACEMENT CHARACTER
+          if (ch === "\0") {
+            return "\uFFFD";
+          } // Control characters and (dependent upon position) numbers get escaped as code points
+
+
+          return ch.slice(0, -1) + "\\" + ch.charCodeAt(ch.length - 1).toString(16) + " ";
+        } // Other potentially-special ASCII characters get backslash-escaped
+
+
+        return "\\" + ch;
+      },
+          // Used for iframes
+      // See setDocument()
+      // Removing the function wrapper causes a "Permission Denied"
+      // error in IE
+      unloadHandler = function () {
+        setDocument();
+      },
+          disabledAncestor = addCombinator(function (elem) {
+        return elem.disabled === true && ("form" in elem || "label" in elem);
+      }, {
+        dir: "parentNode",
+        next: "legend"
+      }); // Optimize for push.apply( _, NodeList )
+
+
+      try {
+        push.apply(arr = slice.call(preferredDoc.childNodes), preferredDoc.childNodes); // Support: Android<4.0
+        // Detect silently failing push.apply
+
+        arr[preferredDoc.childNodes.length].nodeType;
+      } catch (e) {
+        push = {
+          apply: arr.length ? // Leverage slice if possible
+          function (target, els) {
+            push_native.apply(target, slice.call(els));
+          } : // Support: IE<9
+          // Otherwise append directly
+          function (target, els) {
+            var j = target.length,
+                i = 0; // Can't trust NodeList.length
+
+            while (target[j++] = els[i++]) {}
+
+            target.length = j - 1;
+          }
+        };
+      }
+
+      function Sizzle(selector, context, results, seed) {
+        var m,
+            i,
+            elem,
+            nid,
+            match,
+            groups,
+            newSelector,
+            newContext = context && context.ownerDocument,
+            // nodeType defaults to 9, since context defaults to document
+        nodeType = context ? context.nodeType : 9;
+        results = results || []; // Return early from calls with invalid selector or context
+
+        if (typeof selector !== "string" || !selector || nodeType !== 1 && nodeType !== 9 && nodeType !== 11) {
+          return results;
+        } // Try to shortcut find operations (as opposed to filters) in HTML documents
+
+
+        if (!seed) {
+          if ((context ? context.ownerDocument || context : preferredDoc) !== document) {
+            setDocument(context);
+          }
+
+          context = context || document;
+
+          if (documentIsHTML) {
+            // If the selector is sufficiently simple, try using a "get*By*" DOM method
+            // (excepting DocumentFragment context, where the methods don't exist)
+            if (nodeType !== 11 && (match = rquickExpr.exec(selector))) {
+              // ID selector
+              if (m = match[1]) {
+                // Document context
+                if (nodeType === 9) {
+                  if (elem = context.getElementById(m)) {
+                    // Support: IE, Opera, Webkit
+                    // TODO: identify versions
+                    // getElementById can match elements by name instead of ID
+                    if (elem.id === m) {
+                      results.push(elem);
+                      return results;
+                    }
+                  } else {
+                    return results;
+                  } // Element context
+
+                } else {
+                  // Support: IE, Opera, Webkit
+                  // TODO: identify versions
+                  // getElementById can match elements by name instead of ID
+                  if (newContext && (elem = newContext.getElementById(m)) && contains(context, elem) && elem.id === m) {
+                    results.push(elem);
+                    return results;
+                  }
+                } // Type selector
+
+              } else if (match[2]) {
+                push.apply(results, context.getElementsByTagName(selector));
+                return results; // Class selector
+              } else if ((m = match[3]) && support.getElementsByClassName && context.getElementsByClassName) {
+                push.apply(results, context.getElementsByClassName(m));
+                return results;
+              }
+            } // Take advantage of querySelectorAll
+
+
+            if (support.qsa && !compilerCache[selector + " "] && (!rbuggyQSA || !rbuggyQSA.test(selector))) {
+              if (nodeType !== 1) {
+                newContext = context;
+                newSelector = selector; // qSA looks outside Element context, which is not what we want
+                // Thanks to Andrew Dupont for this workaround technique
+                // Support: IE <=8
+                // Exclude object elements
+              } else if (context.nodeName.toLowerCase() !== "object") {
+                // Capture the context ID, setting it first if necessary
+                if (nid = context.getAttribute("id")) {
+                  nid = nid.replace(rcssescape, fcssescape);
+                } else {
+                  context.setAttribute("id", nid = expando);
+                } // Prefix every selector in the list
+
+
+                groups = tokenize(selector);
+                i = groups.length;
+
+                while (i--) {
+                  groups[i] = "#" + nid + " " + toSelector(groups[i]);
+                }
+
+                newSelector = groups.join(","); // Expand context for sibling selectors
+
+                newContext = rsibling.test(selector) && testContext(context.parentNode) || context;
+              }
+
+              if (newSelector) {
+                try {
+                  push.apply(results, newContext.querySelectorAll(newSelector));
+                  return results;
+                } catch (qsaError) {} finally {
+                  if (nid === expando) {
+                    context.removeAttribute("id");
+                  }
+                }
+              }
+            }
+          }
+        } // All others
+
+
+        return select(selector.replace(rtrim, "$1"), context, results, seed);
+      }
+      /**
+       * Create key-value caches of limited size
+       * @returns {function(string, object)} Returns the Object data after storing it on itself with
+       *    property name the (space-suffixed) string and (if the cache is larger than Expr.cacheLength)
+       *    deleting the oldest entry
+       */
+
+
+      function createCache() {
+        var keys = [];
+
+        function cache(key, value) {
+          // Use (key + " ") to avoid collision with native prototype properties (see Issue #157)
+          if (keys.push(key + " ") > Expr.cacheLength) {
+            // Only keep the most recent entries
+            delete cache[keys.shift()];
+          }
+
+          return cache[key + " "] = value;
+        }
+
+        return cache;
+      }
+      /**
+       * Mark a function for special use by Sizzle
+       * @param {Function} fn The function to mark
+       */
+
+
+      function markFunction(fn) {
+        fn[expando] = true;
+        return fn;
+      }
+      /**
+       * Support testing using an element
+       * @param {Function} fn Passed the created element and returns a boolean result
+       */
+
+
+      function assert(fn) {
+        var el = document.createElement("fieldset");
+
+        try {
+          return !!fn(el);
+        } catch (e) {
+          return false;
+        } finally {
+          // Remove from its parent by default
+          if (el.parentNode) {
+            el.parentNode.removeChild(el);
+          } // release memory in IE
+
+
+          el = null;
+        }
+      }
+      /**
+       * Checks document order of two siblings
+       * @param {Element} a
+       * @param {Element} b
+       * @returns {Number} Returns less than 0 if a precedes b, greater than 0 if a follows b
+       */
+
+
+      function siblingCheck(a, b) {
+        var cur = b && a,
+            diff = cur && a.nodeType === 1 && b.nodeType === 1 && a.sourceIndex - b.sourceIndex; // Use IE sourceIndex if available on both nodes
+
+        if (diff) {
+          return diff;
+        } // Check if b follows a
+
+
+        if (cur) {
+          while (cur = cur.nextSibling) {
+            if (cur === b) {
+              return -1;
+            }
+          }
+        }
+
+        return a ? 1 : -1;
+      }
+      /**
+       * Returns a function to use in pseudos for input types
+       * @param {String} type
+       */
+
+
+      function createInputPseudo(type) {
+        return function (elem) {
+          var name = elem.nodeName.toLowerCase();
+          return name === "input" && elem.type === type;
+        };
+      }
+      /**
+       * Returns a function to use in pseudos for buttons
+       * @param {String} type
+       */
+
+
+      function createButtonPseudo(type) {
+        return function (elem) {
+          var name = elem.nodeName.toLowerCase();
+          return (name === "input" || name === "button") && elem.type === type;
+        };
+      }
+      /**
+       * Returns a function to use in pseudos for :enabled/:disabled
+       * @param {Boolean} disabled true for :disabled; false for :enabled
+       */
+
+
+      function createDisabledPseudo(disabled) {
+        // Known :disabled false positives: fieldset[disabled] > legend:nth-of-type(n+2) :can-disable
+        return function (elem) {
+          // Only certain elements can match :enabled or :disabled
+          // https://html.spec.whatwg.org/multipage/scripting.html#selector-enabled
+          // https://html.spec.whatwg.org/multipage/scripting.html#selector-disabled
+          if ("form" in elem) {
+            // Check for inherited disabledness on relevant non-disabled elements:
+            // * listed form-associated elements in a disabled fieldset
+            //   https://html.spec.whatwg.org/multipage/forms.html#category-listed
+            //   https://html.spec.whatwg.org/multipage/forms.html#concept-fe-disabled
+            // * option elements in a disabled optgroup
+            //   https://html.spec.whatwg.org/multipage/forms.html#concept-option-disabled
+            // All such elements have a "form" property.
+            if (elem.parentNode && elem.disabled === false) {
+              // Option elements defer to a parent optgroup if present
+              if ("label" in elem) {
+                if ("label" in elem.parentNode) {
+                  return elem.parentNode.disabled === disabled;
+                } else {
+                  return elem.disabled === disabled;
+                }
+              } // Support: IE 6 - 11
+              // Use the isDisabled shortcut property to check for disabled fieldset ancestors
+
+
+              return elem.isDisabled === disabled || // Where there is no isDisabled, check manually
+
+              /* jshint -W018 */
+              elem.isDisabled !== !disabled && disabledAncestor(elem) === disabled;
+            }
+
+            return elem.disabled === disabled; // Try to winnow out elements that can't be disabled before trusting the disabled property.
+            // Some victims get caught in our net (label, legend, menu, track), but it shouldn't
+            // even exist on them, let alone have a boolean value.
+          } else if ("label" in elem) {
+            return elem.disabled === disabled;
+          } // Remaining elements are neither :enabled nor :disabled
+
+
+          return false;
+        };
+      }
+      /**
+       * Returns a function to use in pseudos for positionals
+       * @param {Function} fn
+       */
+
+
+      function createPositionalPseudo(fn) {
+        return markFunction(function (argument) {
+          argument = +argument;
+          return markFunction(function (seed, matches) {
+            var j,
+                matchIndexes = fn([], seed.length, argument),
+                i = matchIndexes.length; // Match elements found at the specified indexes
+
+            while (i--) {
+              if (seed[j = matchIndexes[i]]) {
+                seed[j] = !(matches[j] = seed[j]);
+              }
+            }
+          });
+        });
+      }
+      /**
+       * Checks a node for validity as a Sizzle context
+       * @param {Element|Object=} context
+       * @returns {Element|Object|Boolean} The input node if acceptable, otherwise a falsy value
+       */
+
+
+      function testContext(context) {
+        return context && typeof context.getElementsByTagName !== "undefined" && context;
+      } // Expose support vars for convenience
+
+
+      support = Sizzle.support = {};
+      /**
+       * Detects XML nodes
+       * @param {Element|Object} elem An element or a document
+       * @returns {Boolean} True iff elem is a non-HTML XML node
+       */
+
+      isXML = Sizzle.isXML = function (elem) {
+        // documentElement is verified for cases where it doesn't yet exist
+        // (such as loading iframes in IE - #4833)
+        var documentElement = elem && (elem.ownerDocument || elem).documentElement;
+        return documentElement ? documentElement.nodeName !== "HTML" : false;
+      };
+      /**
+       * Sets document-related variables once based on the current document
+       * @param {Element|Object} [doc] An element or document object to use to set the document
+       * @returns {Object} Returns the current document
+       */
+
+
+      setDocument = Sizzle.setDocument = function (node) {
+        var hasCompare,
+            subWindow,
+            doc = node ? node.ownerDocument || node : preferredDoc; // Return early if doc is invalid or already selected
+
+        if (doc === document || doc.nodeType !== 9 || !doc.documentElement) {
+          return document;
+        } // Update global variables
+
+
+        document = doc;
+        docElem = document.documentElement;
+        documentIsHTML = !isXML(document); // Support: IE 9-11, Edge
+        // Accessing iframe documents after unload throws "permission denied" errors (jQuery #13936)
+
+        if (preferredDoc !== document && (subWindow = document.defaultView) && subWindow.top !== subWindow) {
+          // Support: IE 11, Edge
+          if (subWindow.addEventListener) {
+            subWindow.addEventListener("unload", unloadHandler, false); // Support: IE 9 - 10 only
+          } else if (subWindow.attachEvent) {
+            subWindow.attachEvent("onunload", unloadHandler);
+          }
+        }
+        /* Attributes
+        ---------------------------------------------------------------------- */
+        // Support: IE<8
+        // Verify that getAttribute really returns attributes and not properties
+        // (excepting IE8 booleans)
+
+
+        support.attributes = assert(function (el) {
+          el.className = "i";
+          return !el.getAttribute("className");
+        });
+        /* getElement(s)By*
+        ---------------------------------------------------------------------- */
+        // Check if getElementsByTagName("*") returns only elements
+
+        support.getElementsByTagName = assert(function (el) {
+          el.appendChild(document.createComment(""));
+          return !el.getElementsByTagName("*").length;
+        }); // Support: IE<9
+
+        support.getElementsByClassName = rnative.test(document.getElementsByClassName); // Support: IE<10
+        // Check if getElementById returns elements by name
+        // The broken getElementById methods don't pick up programmatically-set names,
+        // so use a roundabout getElementsByName test
+
+        support.getById = assert(function (el) {
+          docElem.appendChild(el).id = expando;
+          return !document.getElementsByName || !document.getElementsByName(expando).length;
+        }); // ID filter and find
+
+        if (support.getById) {
+          Expr.filter["ID"] = function (id) {
+            var attrId = id.replace(runescape, funescape);
+            return function (elem) {
+              return elem.getAttribute("id") === attrId;
+            };
+          };
+
+          Expr.find["ID"] = function (id, context) {
+            if (typeof context.getElementById !== "undefined" && documentIsHTML) {
+              var elem = context.getElementById(id);
+              return elem ? [elem] : [];
+            }
+          };
+        } else {
+          Expr.filter["ID"] = function (id) {
+            var attrId = id.replace(runescape, funescape);
+            return function (elem) {
+              var node = typeof elem.getAttributeNode !== "undefined" && elem.getAttributeNode("id");
+              return node && node.value === attrId;
+            };
+          }; // Support: IE 6 - 7 only
+          // getElementById is not reliable as a find shortcut
+
+
+          Expr.find["ID"] = function (id, context) {
+            if (typeof context.getElementById !== "undefined" && documentIsHTML) {
+              var node,
+                  i,
+                  elems,
+                  elem = context.getElementById(id);
+
+              if (elem) {
+                // Verify the id attribute
+                node = elem.getAttributeNode("id");
+
+                if (node && node.value === id) {
+                  return [elem];
+                } // Fall back on getElementsByName
+
+
+                elems = context.getElementsByName(id);
+                i = 0;
+
+                while (elem = elems[i++]) {
+                  node = elem.getAttributeNode("id");
+
+                  if (node && node.value === id) {
+                    return [elem];
+                  }
+                }
+              }
+
+              return [];
+            }
+          };
+        } // Tag
+
+
+        Expr.find["TAG"] = support.getElementsByTagName ? function (tag, context) {
+          if (typeof context.getElementsByTagName !== "undefined") {
+            return context.getElementsByTagName(tag); // DocumentFragment nodes don't have gEBTN
+          } else if (support.qsa) {
+            return context.querySelectorAll(tag);
+          }
+        } : function (tag, context) {
+          var elem,
+              tmp = [],
+              i = 0,
+              // By happy coincidence, a (broken) gEBTN appears on DocumentFragment nodes too
+          results = context.getElementsByTagName(tag); // Filter out possible comments
+
+          if (tag === "*") {
+            while (elem = results[i++]) {
+              if (elem.nodeType === 1) {
+                tmp.push(elem);
+              }
+            }
+
+            return tmp;
+          }
+
+          return results;
+        }; // Class
+
+        Expr.find["CLASS"] = support.getElementsByClassName && function (className, context) {
+          if (typeof context.getElementsByClassName !== "undefined" && documentIsHTML) {
+            return context.getElementsByClassName(className);
+          }
+        };
+        /* QSA/matchesSelector
+        ---------------------------------------------------------------------- */
+        // QSA and matchesSelector support
+        // matchesSelector(:active) reports false when true (IE9/Opera 11.5)
+
+
+        rbuggyMatches = []; // qSa(:focus) reports false when true (Chrome 21)
+        // We allow this because of a bug in IE8/9 that throws an error
+        // whenever `document.activeElement` is accessed on an iframe
+        // So, we allow :focus to pass through QSA all the time to avoid the IE error
+        // See https://bugs.jquery.com/ticket/13378
+
+        rbuggyQSA = [];
+
+        if (support.qsa = rnative.test(document.querySelectorAll)) {
+          // Build QSA regex
+          // Regex strategy adopted from Diego Perini
+          assert(function (el) {
+            // Select is set to empty string on purpose
+            // This is to test IE's treatment of not explicitly
+            // setting a boolean content attribute,
+            // since its presence should be enough
+            // https://bugs.jquery.com/ticket/12359
+            docElem.appendChild(el).innerHTML = "<a id='" + expando + "'></a>" + "<select id='" + expando + "-\r\\' msallowcapture=''>" + "<option selected=''></option></select>"; // Support: IE8, Opera 11-12.16
+            // Nothing should be selected when empty strings follow ^= or $= or *=
+            // The test attribute must be unknown in Opera but "safe" for WinRT
+            // https://msdn.microsoft.com/en-us/library/ie/hh465388.aspx#attribute_section
+
+            if (el.querySelectorAll("[msallowcapture^='']").length) {
+              rbuggyQSA.push("[*^$]=" + whitespace + "*(?:''|\"\")");
+            } // Support: IE8
+            // Boolean attributes and "value" are not treated correctly
+
+
+            if (!el.querySelectorAll("[selected]").length) {
+              rbuggyQSA.push("\\[" + whitespace + "*(?:value|" + booleans + ")");
+            } // Support: Chrome<29, Android<4.4, Safari<7.0+, iOS<7.0+, PhantomJS<1.9.8+
+
+
+            if (!el.querySelectorAll("[id~=" + expando + "-]").length) {
+              rbuggyQSA.push("~=");
+            } // Webkit/Opera - :checked should return selected option elements
+            // http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
+            // IE8 throws error here and will not see later tests
+
+
+            if (!el.querySelectorAll(":checked").length) {
+              rbuggyQSA.push(":checked");
+            } // Support: Safari 8+, iOS 8+
+            // https://bugs.webkit.org/show_bug.cgi?id=136851
+            // In-page `selector#id sibling-combinator selector` fails
+
+
+            if (!el.querySelectorAll("a#" + expando + "+*").length) {
+              rbuggyQSA.push(".#.+[+~]");
+            }
+          });
+          assert(function (el) {
+            el.innerHTML = "<a href='' disabled='disabled'></a>" + "<select disabled='disabled'><option/></select>"; // Support: Windows 8 Native Apps
+            // The type and name attributes are restricted during .innerHTML assignment
+
+            var input = document.createElement("input");
+            input.setAttribute("type", "hidden");
+            el.appendChild(input).setAttribute("name", "D"); // Support: IE8
+            // Enforce case-sensitivity of name attribute
+
+            if (el.querySelectorAll("[name=d]").length) {
+              rbuggyQSA.push("name" + whitespace + "*[*^$|!~]?=");
+            } // FF 3.5 - :enabled/:disabled and hidden elements (hidden elements are still enabled)
+            // IE8 throws error here and will not see later tests
+
+
+            if (el.querySelectorAll(":enabled").length !== 2) {
+              rbuggyQSA.push(":enabled", ":disabled");
+            } // Support: IE9-11+
+            // IE's :disabled selector does not pick up the children of disabled fieldsets
+
+
+            docElem.appendChild(el).disabled = true;
+
+            if (el.querySelectorAll(":disabled").length !== 2) {
+              rbuggyQSA.push(":enabled", ":disabled");
+            } // Opera 10-11 does not throw on post-comma invalid pseudos
+
+
+            el.querySelectorAll("*,:x");
+            rbuggyQSA.push(",.*:");
+          });
+        }
+
+        if (support.matchesSelector = rnative.test(matches = docElem.matches || docElem.webkitMatchesSelector || docElem.mozMatchesSelector || docElem.oMatchesSelector || docElem.msMatchesSelector)) {
+          assert(function (el) {
+            // Check to see if it's possible to do matchesSelector
+            // on a disconnected node (IE 9)
+            support.disconnectedMatch = matches.call(el, "*"); // This should fail with an exception
+            // Gecko does not error, returns false instead
+
+            matches.call(el, "[s!='']:x");
+            rbuggyMatches.push("!=", pseudos);
+          });
+        }
+
+        rbuggyQSA = rbuggyQSA.length && new RegExp(rbuggyQSA.join("|"));
+        rbuggyMatches = rbuggyMatches.length && new RegExp(rbuggyMatches.join("|"));
+        /* Contains
+        ---------------------------------------------------------------------- */
+
+        hasCompare = rnative.test(docElem.compareDocumentPosition); // Element contains another
+        // Purposefully self-exclusive
+        // As in, an element does not contain itself
+
+        contains = hasCompare || rnative.test(docElem.contains) ? function (a, b) {
+          var adown = a.nodeType === 9 ? a.documentElement : a,
+              bup = b && b.parentNode;
+          return a === bup || !!(bup && bup.nodeType === 1 && (adown.contains ? adown.contains(bup) : a.compareDocumentPosition && a.compareDocumentPosition(bup) & 16));
+        } : function (a, b) {
+          if (b) {
+            while (b = b.parentNode) {
+              if (b === a) {
+                return true;
+              }
+            }
+          }
+
+          return false;
+        };
+        /* Sorting
+        ---------------------------------------------------------------------- */
+        // Document order sorting
+
+        sortOrder = hasCompare ? function (a, b) {
+          // Flag for duplicate removal
+          if (a === b) {
+            hasDuplicate = true;
+            return 0;
+          } // Sort on method existence if only one input has compareDocumentPosition
+
+
+          var compare = !a.compareDocumentPosition - !b.compareDocumentPosition;
+
+          if (compare) {
+            return compare;
+          } // Calculate position if both inputs belong to the same document
+
+
+          compare = (a.ownerDocument || a) === (b.ownerDocument || b) ? a.compareDocumentPosition(b) : // Otherwise we know they are disconnected
+          1; // Disconnected nodes
+
+          if (compare & 1 || !support.sortDetached && b.compareDocumentPosition(a) === compare) {
+            // Choose the first element that is related to our preferred document
+            if (a === document || a.ownerDocument === preferredDoc && contains(preferredDoc, a)) {
+              return -1;
+            }
+
+            if (b === document || b.ownerDocument === preferredDoc && contains(preferredDoc, b)) {
+              return 1;
+            } // Maintain original order
+
+
+            return sortInput ? indexOf(sortInput, a) - indexOf(sortInput, b) : 0;
+          }
+
+          return compare & 4 ? -1 : 1;
+        } : function (a, b) {
+          // Exit early if the nodes are identical
+          if (a === b) {
+            hasDuplicate = true;
+            return 0;
+          }
+
+          var cur,
+              i = 0,
+              aup = a.parentNode,
+              bup = b.parentNode,
+              ap = [a],
+              bp = [b]; // Parentless nodes are either documents or disconnected
+
+          if (!aup || !bup) {
+            return a === document ? -1 : b === document ? 1 : aup ? -1 : bup ? 1 : sortInput ? indexOf(sortInput, a) - indexOf(sortInput, b) : 0; // If the nodes are siblings, we can do a quick check
+          } else if (aup === bup) {
+            return siblingCheck(a, b);
+          } // Otherwise we need full lists of their ancestors for comparison
+
+
+          cur = a;
+
+          while (cur = cur.parentNode) {
+            ap.unshift(cur);
+          }
+
+          cur = b;
+
+          while (cur = cur.parentNode) {
+            bp.unshift(cur);
+          } // Walk down the tree looking for a discrepancy
+
+
+          while (ap[i] === bp[i]) {
+            i++;
+          }
+
+          return i ? // Do a sibling check if the nodes have a common ancestor
+          siblingCheck(ap[i], bp[i]) : // Otherwise nodes in our document sort first
+          ap[i] === preferredDoc ? -1 : bp[i] === preferredDoc ? 1 : 0;
+        };
+        return document;
+      };
+
+      Sizzle.matches = function (expr, elements) {
+        return Sizzle(expr, null, null, elements);
+      };
+
+      Sizzle.matchesSelector = function (elem, expr) {
+        // Set document vars if needed
+        if ((elem.ownerDocument || elem) !== document) {
+          setDocument(elem);
+        } // Make sure that attribute selectors are quoted
+
+
+        expr = expr.replace(rattributeQuotes, "='$1']");
+
+        if (support.matchesSelector && documentIsHTML && !compilerCache[expr + " "] && (!rbuggyMatches || !rbuggyMatches.test(expr)) && (!rbuggyQSA || !rbuggyQSA.test(expr))) {
+          try {
+            var ret = matches.call(elem, expr); // IE 9's matchesSelector returns false on disconnected nodes
+
+            if (ret || support.disconnectedMatch || // As well, disconnected nodes are said to be in a document
+            // fragment in IE 9
+            elem.document && elem.document.nodeType !== 11) {
+              return ret;
+            }
+          } catch (e) {}
+        }
+
+        return Sizzle(expr, document, null, [elem]).length > 0;
+      };
+
+      Sizzle.contains = function (context, elem) {
+        // Set document vars if needed
+        if ((context.ownerDocument || context) !== document) {
+          setDocument(context);
+        }
+
+        return contains(context, elem);
+      };
+
+      Sizzle.attr = function (elem, name) {
+        // Set document vars if needed
+        if ((elem.ownerDocument || elem) !== document) {
+          setDocument(elem);
+        }
+
+        var fn = Expr.attrHandle[name.toLowerCase()],
+            // Don't get fooled by Object.prototype properties (jQuery #13807)
+        val = fn && hasOwn.call(Expr.attrHandle, name.toLowerCase()) ? fn(elem, name, !documentIsHTML) : undefined;
+        return val !== undefined ? val : support.attributes || !documentIsHTML ? elem.getAttribute(name) : (val = elem.getAttributeNode(name)) && val.specified ? val.value : null;
+      };
+
+      Sizzle.escape = function (sel) {
+        return (sel + "").replace(rcssescape, fcssescape);
+      };
+
+      Sizzle.error = function (msg) {
+        throw new Error("Syntax error, unrecognized expression: " + msg);
+      };
+      /**
+       * Document sorting and removing duplicates
+       * @param {ArrayLike} results
+       */
+
+
+      Sizzle.uniqueSort = function (results) {
+        var elem,
+            duplicates = [],
+            j = 0,
+            i = 0; // Unless we *know* we can detect duplicates, assume their presence
+
+        hasDuplicate = !support.detectDuplicates;
+        sortInput = !support.sortStable && results.slice(0);
+        results.sort(sortOrder);
+
+        if (hasDuplicate) {
+          while (elem = results[i++]) {
+            if (elem === results[i]) {
+              j = duplicates.push(i);
+            }
+          }
+
+          while (j--) {
+            results.splice(duplicates[j], 1);
+          }
+        } // Clear input after sorting to release objects
+        // See https://github.com/jquery/sizzle/pull/225
+
+
+        sortInput = null;
+        return results;
+      };
+      /**
+       * Utility function for retrieving the text value of an array of DOM nodes
+       * @param {Array|Element} elem
+       */
+
+
+      getText = Sizzle.getText = function (elem) {
+        var node,
+            ret = "",
+            i = 0,
+            nodeType = elem.nodeType;
+
+        if (!nodeType) {
+          // If no nodeType, this is expected to be an array
+          while (node = elem[i++]) {
+            // Do not traverse comment nodes
+            ret += getText(node);
+          }
+        } else if (nodeType === 1 || nodeType === 9 || nodeType === 11) {
+          // Use textContent for elements
+          // innerText usage removed for consistency of new lines (jQuery #11153)
+          if (typeof elem.textContent === "string") {
+            return elem.textContent;
+          } else {
+            // Traverse its children
+            for (elem = elem.firstChild; elem; elem = elem.nextSibling) {
+              ret += getText(elem);
+            }
+          }
+        } else if (nodeType === 3 || nodeType === 4) {
+          return elem.nodeValue;
+        } // Do not include comment or processing instruction nodes
+
+
+        return ret;
+      };
+
+      Expr = Sizzle.selectors = {
+        // Can be adjusted by the user
+        cacheLength: 50,
+        createPseudo: markFunction,
+        match: matchExpr,
+        attrHandle: {},
+        find: {},
+        relative: {
+          ">": {
+            dir: "parentNode",
+            first: true
+          },
+          " ": {
+            dir: "parentNode"
+          },
+          "+": {
+            dir: "previousSibling",
+            first: true
+          },
+          "~": {
+            dir: "previousSibling"
+          }
+        },
+        preFilter: {
+          "ATTR": function (match) {
+            match[1] = match[1].replace(runescape, funescape); // Move the given value to match[3] whether quoted or unquoted
+
+            match[3] = (match[3] || match[4] || match[5] || "").replace(runescape, funescape);
+
+            if (match[2] === "~=") {
+              match[3] = " " + match[3] + " ";
+            }
+
+            return match.slice(0, 4);
+          },
+          "CHILD": function (match) {
+            /* matches from matchExpr["CHILD"]
+            1 type (only|nth|...)
+            2 what (child|of-type)
+            3 argument (even|odd|\d*|\d*n([+-]\d+)?|...)
+            4 xn-component of xn+y argument ([+-]?\d*n|)
+            5 sign of xn-component
+            6 x of xn-component
+            7 sign of y-component
+            8 y of y-component
+            */
+            match[1] = match[1].toLowerCase();
+
+            if (match[1].slice(0, 3) === "nth") {
+              // nth-* requires argument
+              if (!match[3]) {
+                Sizzle.error(match[0]);
+              } // numeric x and y parameters for Expr.filter.CHILD
+              // remember that false/true cast respectively to 0/1
+
+
+              match[4] = +(match[4] ? match[5] + (match[6] || 1) : 2 * (match[3] === "even" || match[3] === "odd"));
+              match[5] = +(match[7] + match[8] || match[3] === "odd"); // other types prohibit arguments
+            } else if (match[3]) {
+              Sizzle.error(match[0]);
+            }
+
+            return match;
+          },
+          "PSEUDO": function (match) {
+            var excess,
+                unquoted = !match[6] && match[2];
+
+            if (matchExpr["CHILD"].test(match[0])) {
+              return null;
+            } // Accept quoted arguments as-is
+
+
+            if (match[3]) {
+              match[2] = match[4] || match[5] || ""; // Strip excess characters from unquoted arguments
+            } else if (unquoted && rpseudo.test(unquoted) && (excess = tokenize(unquoted, true)) && (excess = unquoted.indexOf(")", unquoted.length - excess) - unquoted.length)) {
+              // excess is a negative index
+              match[0] = match[0].slice(0, excess);
+              match[2] = unquoted.slice(0, excess);
+            } // Return only captures needed by the pseudo filter method (type and argument)
+
+
+            return match.slice(0, 3);
+          }
+        },
+        filter: {
+          "TAG": function (nodeNameSelector) {
+            var nodeName = nodeNameSelector.replace(runescape, funescape).toLowerCase();
+            return nodeNameSelector === "*" ? function () {
+              return true;
+            } : function (elem) {
+              return elem.nodeName && elem.nodeName.toLowerCase() === nodeName;
+            };
+          },
+          "CLASS": function (className) {
+            var pattern = classCache[className + " "];
+            return pattern || (pattern = new RegExp("(^|" + whitespace + ")" + className + "(" + whitespace + "|$)")) && classCache(className, function (elem) {
+              return pattern.test(typeof elem.className === "string" && elem.className || typeof elem.getAttribute !== "undefined" && elem.getAttribute("class") || "");
+            });
+          },
+          "ATTR": function (name, operator, check) {
+            return function (elem) {
+              var result = Sizzle.attr(elem, name);
+
+              if (result == null) {
+                return operator === "!=";
+              }
+
+              if (!operator) {
+                return true;
+              }
+
+              result += "";
+              return operator === "=" ? result === check : operator === "!=" ? result !== check : operator === "^=" ? check && result.indexOf(check) === 0 : operator === "*=" ? check && result.indexOf(check) > -1 : operator === "$=" ? check && result.slice(-check.length) === check : operator === "~=" ? (" " + result.replace(rwhitespace, " ") + " ").indexOf(check) > -1 : operator === "|=" ? result === check || result.slice(0, check.length + 1) === check + "-" : false;
+            };
+          },
+          "CHILD": function (type, what, argument, first, last) {
+            var simple = type.slice(0, 3) !== "nth",
+                forward = type.slice(-4) !== "last",
+                ofType = what === "of-type";
+            return first === 1 && last === 0 ? // Shortcut for :nth-*(n)
+            function (elem) {
+              return !!elem.parentNode;
+            } : function (elem, context, xml) {
+              var cache,
+                  uniqueCache,
+                  outerCache,
+                  node,
+                  nodeIndex,
+                  start,
+                  dir = simple !== forward ? "nextSibling" : "previousSibling",
+                  parent = elem.parentNode,
+                  name = ofType && elem.nodeName.toLowerCase(),
+                  useCache = !xml && !ofType,
+                  diff = false;
+
+              if (parent) {
+                // :(first|last|only)-(child|of-type)
+                if (simple) {
+                  while (dir) {
+                    node = elem;
+
+                    while (node = node[dir]) {
+                      if (ofType ? node.nodeName.toLowerCase() === name : node.nodeType === 1) {
+                        return false;
+                      }
+                    } // Reverse direction for :only-* (if we haven't yet done so)
+
+
+                    start = dir = type === "only" && !start && "nextSibling";
+                  }
+
+                  return true;
+                }
+
+                start = [forward ? parent.firstChild : parent.lastChild]; // non-xml :nth-child(...) stores cache data on `parent`
+
+                if (forward && useCache) {
+                  // Seek `elem` from a previously-cached index
+                  // ...in a gzip-friendly way
+                  node = parent;
+                  outerCache = node[expando] || (node[expando] = {}); // Support: IE <9 only
+                  // Defend against cloned attroperties (jQuery gh-1709)
+
+                  uniqueCache = outerCache[node.uniqueID] || (outerCache[node.uniqueID] = {});
+                  cache = uniqueCache[type] || [];
+                  nodeIndex = cache[0] === dirruns && cache[1];
+                  diff = nodeIndex && cache[2];
+                  node = nodeIndex && parent.childNodes[nodeIndex];
+
+                  while (node = ++nodeIndex && node && node[dir] || (diff = nodeIndex = 0) || start.pop()) {
+                    // When found, cache indexes on `parent` and break
+                    if (node.nodeType === 1 && ++diff && node === elem) {
+                      uniqueCache[type] = [dirruns, nodeIndex, diff];
+                      break;
+                    }
+                  }
+                } else {
+                  // Use previously-cached element index if available
+                  if (useCache) {
+                    // ...in a gzip-friendly way
+                    node = elem;
+                    outerCache = node[expando] || (node[expando] = {}); // Support: IE <9 only
+                    // Defend against cloned attroperties (jQuery gh-1709)
+
+                    uniqueCache = outerCache[node.uniqueID] || (outerCache[node.uniqueID] = {});
+                    cache = uniqueCache[type] || [];
+                    nodeIndex = cache[0] === dirruns && cache[1];
+                    diff = nodeIndex;
+                  } // xml :nth-child(...)
+                  // or :nth-last-child(...) or :nth(-last)?-of-type(...)
+
+
+                  if (diff === false) {
+                    // Use the same loop as above to seek `elem` from the start
+                    while (node = ++nodeIndex && node && node[dir] || (diff = nodeIndex = 0) || start.pop()) {
+                      if ((ofType ? node.nodeName.toLowerCase() === name : node.nodeType === 1) && ++diff) {
+                        // Cache the index of each encountered element
+                        if (useCache) {
+                          outerCache = node[expando] || (node[expando] = {}); // Support: IE <9 only
+                          // Defend against cloned attroperties (jQuery gh-1709)
+
+                          uniqueCache = outerCache[node.uniqueID] || (outerCache[node.uniqueID] = {});
+                          uniqueCache[type] = [dirruns, diff];
+                        }
+
+                        if (node === elem) {
+                          break;
+                        }
+                      }
+                    }
+                  }
+                } // Incorporate the offset, then check against cycle size
+
+
+                diff -= last;
+                return diff === first || diff % first === 0 && diff / first >= 0;
+              }
+            };
+          },
+          "PSEUDO": function (pseudo, argument) {
+            // pseudo-class names are case-insensitive
+            // http://www.w3.org/TR/selectors/#pseudo-classes
+            // Prioritize by case sensitivity in case custom pseudos are added with uppercase letters
+            // Remember that setFilters inherits from pseudos
+            var args,
+                fn = Expr.pseudos[pseudo] || Expr.setFilters[pseudo.toLowerCase()] || Sizzle.error("unsupported pseudo: " + pseudo); // The user may use createPseudo to indicate that
+            // arguments are needed to create the filter function
+            // just as Sizzle does
+
+            if (fn[expando]) {
+              return fn(argument);
+            } // But maintain support for old signatures
+
+
+            if (fn.length > 1) {
+              args = [pseudo, pseudo, "", argument];
+              return Expr.setFilters.hasOwnProperty(pseudo.toLowerCase()) ? markFunction(function (seed, matches) {
+                var idx,
+                    matched = fn(seed, argument),
+                    i = matched.length;
+
+                while (i--) {
+                  idx = indexOf(seed, matched[i]);
+                  seed[idx] = !(matches[idx] = matched[i]);
+                }
+              }) : function (elem) {
+                return fn(elem, 0, args);
+              };
+            }
+
+            return fn;
+          }
+        },
+        pseudos: {
+          // Potentially complex pseudos
+          "not": markFunction(function (selector) {
+            // Trim the selector passed to compile
+            // to avoid treating leading and trailing
+            // spaces as combinators
+            var input = [],
+                results = [],
+                matcher = compile(selector.replace(rtrim, "$1"));
+            return matcher[expando] ? markFunction(function (seed, matches, context, xml) {
+              var elem,
+                  unmatched = matcher(seed, null, xml, []),
+                  i = seed.length; // Match elements unmatched by `matcher`
+
+              while (i--) {
+                if (elem = unmatched[i]) {
+                  seed[i] = !(matches[i] = elem);
+                }
+              }
+            }) : function (elem, context, xml) {
+              input[0] = elem;
+              matcher(input, null, xml, results); // Don't keep the element (issue #299)
+
+              input[0] = null;
+              return !results.pop();
+            };
+          }),
+          "has": markFunction(function (selector) {
+            return function (elem) {
+              return Sizzle(selector, elem).length > 0;
+            };
+          }),
+          "contains": markFunction(function (text) {
+            text = text.replace(runescape, funescape);
+            return function (elem) {
+              return (elem.textContent || elem.innerText || getText(elem)).indexOf(text) > -1;
+            };
+          }),
+          // "Whether an element is represented by a :lang() selector
+          // is based solely on the element's language value
+          // being equal to the identifier C,
+          // or beginning with the identifier C immediately followed by "-".
+          // The matching of C against the element's language value is performed case-insensitively.
+          // The identifier C does not have to be a valid language name."
+          // http://www.w3.org/TR/selectors/#lang-pseudo
+          "lang": markFunction(function (lang) {
+            // lang value must be a valid identifier
+            if (!ridentifier.test(lang || "")) {
+              Sizzle.error("unsupported lang: " + lang);
+            }
+
+            lang = lang.replace(runescape, funescape).toLowerCase();
+            return function (elem) {
+              var elemLang;
+
+              do {
+                if (elemLang = documentIsHTML ? elem.lang : elem.getAttribute("xml:lang") || elem.getAttribute("lang")) {
+                  elemLang = elemLang.toLowerCase();
+                  return elemLang === lang || elemLang.indexOf(lang + "-") === 0;
+                }
+              } while ((elem = elem.parentNode) && elem.nodeType === 1);
+
+              return false;
+            };
+          }),
+          // Miscellaneous
+          "target": function (elem) {
+            var hash = window.location && window.location.hash;
+            return hash && hash.slice(1) === elem.id;
+          },
+          "root": function (elem) {
+            return elem === docElem;
+          },
+          "focus": function (elem) {
+            return elem === document.activeElement && (!document.hasFocus || document.hasFocus()) && !!(elem.type || elem.href || ~elem.tabIndex);
+          },
+          // Boolean properties
+          "enabled": createDisabledPseudo(false),
+          "disabled": createDisabledPseudo(true),
+          "checked": function (elem) {
+            // In CSS3, :checked should return both checked and selected elements
+            // http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
+            var nodeName = elem.nodeName.toLowerCase();
+            return nodeName === "input" && !!elem.checked || nodeName === "option" && !!elem.selected;
+          },
+          "selected": function (elem) {
+            // Accessing this property makes selected-by-default
+            // options in Safari work properly
+            if (elem.parentNode) {
+              elem.parentNode.selectedIndex;
+            }
+
+            return elem.selected === true;
+          },
+          // Contents
+          "empty": function (elem) {
+            // http://www.w3.org/TR/selectors/#empty-pseudo
+            // :empty is negated by element (1) or content nodes (text: 3; cdata: 4; entity ref: 5),
+            //   but not by others (comment: 8; processing instruction: 7; etc.)
+            // nodeType < 6 works because attributes (2) do not appear as children
+            for (elem = elem.firstChild; elem; elem = elem.nextSibling) {
+              if (elem.nodeType < 6) {
+                return false;
+              }
+            }
+
+            return true;
+          },
+          "parent": function (elem) {
+            return !Expr.pseudos["empty"](elem);
+          },
+          // Element/input types
+          "header": function (elem) {
+            return rheader.test(elem.nodeName);
+          },
+          "input": function (elem) {
+            return rinputs.test(elem.nodeName);
+          },
+          "button": function (elem) {
+            var name = elem.nodeName.toLowerCase();
+            return name === "input" && elem.type === "button" || name === "button";
+          },
+          "text": function (elem) {
+            var attr;
+            return elem.nodeName.toLowerCase() === "input" && elem.type === "text" && ((attr = elem.getAttribute("type")) == null || attr.toLowerCase() === "text");
+          },
+          // Position-in-collection
+          "first": createPositionalPseudo(function () {
+            return [0];
+          }),
+          "last": createPositionalPseudo(function (matchIndexes, length) {
+            return [length - 1];
+          }),
+          "eq": createPositionalPseudo(function (matchIndexes, length, argument) {
+            return [argument < 0 ? argument + length : argument];
+          }),
+          "even": createPositionalPseudo(function (matchIndexes, length) {
+            var i = 0;
+
+            for (; i < length; i += 2) {
+              matchIndexes.push(i);
+            }
+
+            return matchIndexes;
+          }),
+          "odd": createPositionalPseudo(function (matchIndexes, length) {
+            var i = 1;
+
+            for (; i < length; i += 2) {
+              matchIndexes.push(i);
+            }
+
+            return matchIndexes;
+          }),
+          "lt": createPositionalPseudo(function (matchIndexes, length, argument) {
+            var i = argument < 0 ? argument + length : argument;
+
+            for (; --i >= 0;) {
+              matchIndexes.push(i);
+            }
+
+            return matchIndexes;
+          }),
+          "gt": createPositionalPseudo(function (matchIndexes, length, argument) {
+            var i = argument < 0 ? argument + length : argument;
+
+            for (; ++i < length;) {
+              matchIndexes.push(i);
+            }
+
+            return matchIndexes;
+          })
+        }
+      };
+      Expr.pseudos["nth"] = Expr.pseudos["eq"]; // Add button/input type pseudos
+
+      for (i in {
+        radio: true,
+        checkbox: true,
+        file: true,
+        password: true,
+        image: true
+      }) {
+        Expr.pseudos[i] = createInputPseudo(i);
+      }
+
+      for (i in {
+        submit: true,
+        reset: true
+      }) {
+        Expr.pseudos[i] = createButtonPseudo(i);
+      } // Easy API for creating new setFilters
+
+
+      function setFilters() {}
+
+      setFilters.prototype = Expr.filters = Expr.pseudos;
+      Expr.setFilters = new setFilters();
+
+      tokenize = Sizzle.tokenize = function (selector, parseOnly) {
+        var matched,
+            match,
+            tokens,
+            type,
+            soFar,
+            groups,
+            preFilters,
+            cached = tokenCache[selector + " "];
+
+        if (cached) {
+          return parseOnly ? 0 : cached.slice(0);
+        }
+
+        soFar = selector;
+        groups = [];
+        preFilters = Expr.preFilter;
+
+        while (soFar) {
+          // Comma and first run
+          if (!matched || (match = rcomma.exec(soFar))) {
+            if (match) {
+              // Don't consume trailing commas as valid
+              soFar = soFar.slice(match[0].length) || soFar;
+            }
+
+            groups.push(tokens = []);
+          }
+
+          matched = false; // Combinators
+
+          if (match = rcombinators.exec(soFar)) {
+            matched = match.shift();
+            tokens.push({
+              value: matched,
+              // Cast descendant combinators to space
+              type: match[0].replace(rtrim, " ")
+            });
+            soFar = soFar.slice(matched.length);
+          } // Filters
+
+
+          for (type in Expr.filter) {
+            if ((match = matchExpr[type].exec(soFar)) && (!preFilters[type] || (match = preFilters[type](match)))) {
+              matched = match.shift();
+              tokens.push({
+                value: matched,
+                type: type,
+                matches: match
+              });
+              soFar = soFar.slice(matched.length);
+            }
+          }
+
+          if (!matched) {
+            break;
+          }
+        } // Return the length of the invalid excess
+        // if we're just parsing
+        // Otherwise, throw an error or return tokens
+
+
+        return parseOnly ? soFar.length : soFar ? Sizzle.error(selector) : // Cache the tokens
+        tokenCache(selector, groups).slice(0);
+      };
+
+      function toSelector(tokens) {
+        var i = 0,
+            len = tokens.length,
+            selector = "";
+
+        for (; i < len; i++) {
+          selector += tokens[i].value;
+        }
+
+        return selector;
+      }
+
+      function addCombinator(matcher, combinator, base) {
+        var dir = combinator.dir,
+            skip = combinator.next,
+            key = skip || dir,
+            checkNonElements = base && key === "parentNode",
+            doneName = done++;
+        return combinator.first ? // Check against closest ancestor/preceding element
+        function (elem, context, xml) {
+          while (elem = elem[dir]) {
+            if (elem.nodeType === 1 || checkNonElements) {
+              return matcher(elem, context, xml);
+            }
+          }
+
+          return false;
+        } : // Check against all ancestor/preceding elements
+        function (elem, context, xml) {
+          var oldCache,
+              uniqueCache,
+              outerCache,
+              newCache = [dirruns, doneName]; // We can't set arbitrary data on XML nodes, so they don't benefit from combinator caching
+
+          if (xml) {
+            while (elem = elem[dir]) {
+              if (elem.nodeType === 1 || checkNonElements) {
+                if (matcher(elem, context, xml)) {
+                  return true;
+                }
+              }
+            }
+          } else {
+            while (elem = elem[dir]) {
+              if (elem.nodeType === 1 || checkNonElements) {
+                outerCache = elem[expando] || (elem[expando] = {}); // Support: IE <9 only
+                // Defend against cloned attroperties (jQuery gh-1709)
+
+                uniqueCache = outerCache[elem.uniqueID] || (outerCache[elem.uniqueID] = {});
+
+                if (skip && skip === elem.nodeName.toLowerCase()) {
+                  elem = elem[dir] || elem;
+                } else if ((oldCache = uniqueCache[key]) && oldCache[0] === dirruns && oldCache[1] === doneName) {
+                  // Assign to newCache so results back-propagate to previous elements
+                  return newCache[2] = oldCache[2];
+                } else {
+                  // Reuse newcache so results back-propagate to previous elements
+                  uniqueCache[key] = newCache; // A match means we're done; a fail means we have to keep checking
+
+                  if (newCache[2] = matcher(elem, context, xml)) {
+                    return true;
+                  }
+                }
+              }
+            }
+          }
+
+          return false;
+        };
+      }
+
+      function elementMatcher(matchers) {
+        return matchers.length > 1 ? function (elem, context, xml) {
+          var i = matchers.length;
+
+          while (i--) {
+            if (!matchers[i](elem, context, xml)) {
+              return false;
+            }
+          }
+
+          return true;
+        } : matchers[0];
+      }
+
+      function multipleContexts(selector, contexts, results) {
+        var i = 0,
+            len = contexts.length;
+
+        for (; i < len; i++) {
+          Sizzle(selector, contexts[i], results);
+        }
+
+        return results;
+      }
+
+      function condense(unmatched, map, filter, context, xml) {
+        var elem,
+            newUnmatched = [],
+            i = 0,
+            len = unmatched.length,
+            mapped = map != null;
+
+        for (; i < len; i++) {
+          if (elem = unmatched[i]) {
+            if (!filter || filter(elem, context, xml)) {
+              newUnmatched.push(elem);
+
+              if (mapped) {
+                map.push(i);
+              }
+            }
+          }
+        }
+
+        return newUnmatched;
+      }
+
+      function setMatcher(preFilter, selector, matcher, postFilter, postFinder, postSelector) {
+        if (postFilter && !postFilter[expando]) {
+          postFilter = setMatcher(postFilter);
+        }
+
+        if (postFinder && !postFinder[expando]) {
+          postFinder = setMatcher(postFinder, postSelector);
+        }
+
+        return markFunction(function (seed, results, context, xml) {
+          var temp,
+              i,
+              elem,
+              preMap = [],
+              postMap = [],
+              preexisting = results.length,
+              // Get initial elements from seed or context
+          elems = seed || multipleContexts(selector || "*", context.nodeType ? [context] : context, []),
+              // Prefilter to get matcher input, preserving a map for seed-results synchronization
+          matcherIn = preFilter && (seed || !selector) ? condense(elems, preMap, preFilter, context, xml) : elems,
+              matcherOut = matcher ? // If we have a postFinder, or filtered seed, or non-seed postFilter or preexisting results,
+          postFinder || (seed ? preFilter : preexisting || postFilter) ? // ...intermediate processing is necessary
+          [] : // ...otherwise use results directly
+          results : matcherIn; // Find primary matches
+
+          if (matcher) {
+            matcher(matcherIn, matcherOut, context, xml);
+          } // Apply postFilter
+
+
+          if (postFilter) {
+            temp = condense(matcherOut, postMap);
+            postFilter(temp, [], context, xml); // Un-match failing elements by moving them back to matcherIn
+
+            i = temp.length;
+
+            while (i--) {
+              if (elem = temp[i]) {
+                matcherOut[postMap[i]] = !(matcherIn[postMap[i]] = elem);
+              }
+            }
+          }
+
+          if (seed) {
+            if (postFinder || preFilter) {
+              if (postFinder) {
+                // Get the final matcherOut by condensing this intermediate into postFinder contexts
+                temp = [];
+                i = matcherOut.length;
+
+                while (i--) {
+                  if (elem = matcherOut[i]) {
+                    // Restore matcherIn since elem is not yet a final match
+                    temp.push(matcherIn[i] = elem);
+                  }
+                }
+
+                postFinder(null, matcherOut = [], temp, xml);
+              } // Move matched elements from seed to results to keep them synchronized
+
+
+              i = matcherOut.length;
+
+              while (i--) {
+                if ((elem = matcherOut[i]) && (temp = postFinder ? indexOf(seed, elem) : preMap[i]) > -1) {
+                  seed[temp] = !(results[temp] = elem);
+                }
+              }
+            } // Add elements to results, through postFinder if defined
+
+          } else {
+            matcherOut = condense(matcherOut === results ? matcherOut.splice(preexisting, matcherOut.length) : matcherOut);
+
+            if (postFinder) {
+              postFinder(null, results, matcherOut, xml);
+            } else {
+              push.apply(results, matcherOut);
+            }
+          }
+        });
+      }
+
+      function matcherFromTokens(tokens) {
+        var checkContext,
+            matcher,
+            j,
+            len = tokens.length,
+            leadingRelative = Expr.relative[tokens[0].type],
+            implicitRelative = leadingRelative || Expr.relative[" "],
+            i = leadingRelative ? 1 : 0,
+            // The foundational matcher ensures that elements are reachable from top-level context(s)
+        matchContext = addCombinator(function (elem) {
+          return elem === checkContext;
+        }, implicitRelative, true),
+            matchAnyContext = addCombinator(function (elem) {
+          return indexOf(checkContext, elem) > -1;
+        }, implicitRelative, true),
+            matchers = [function (elem, context, xml) {
+          var ret = !leadingRelative && (xml || context !== outermostContext) || ((checkContext = context).nodeType ? matchContext(elem, context, xml) : matchAnyContext(elem, context, xml)); // Avoid hanging onto element (issue #299)
+
+          checkContext = null;
+          return ret;
+        }];
+
+        for (; i < len; i++) {
+          if (matcher = Expr.relative[tokens[i].type]) {
+            matchers = [addCombinator(elementMatcher(matchers), matcher)];
+          } else {
+            matcher = Expr.filter[tokens[i].type].apply(null, tokens[i].matches); // Return special upon seeing a positional matcher
+
+            if (matcher[expando]) {
+              // Find the next relative operator (if any) for proper handling
+              j = ++i;
+
+              for (; j < len; j++) {
+                if (Expr.relative[tokens[j].type]) {
+                  break;
+                }
+              }
+
+              return setMatcher(i > 1 && elementMatcher(matchers), i > 1 && toSelector( // If the preceding token was a descendant combinator, insert an implicit any-element `*`
+              tokens.slice(0, i - 1).concat({
+                value: tokens[i - 2].type === " " ? "*" : ""
+              })).replace(rtrim, "$1"), matcher, i < j && matcherFromTokens(tokens.slice(i, j)), j < len && matcherFromTokens(tokens = tokens.slice(j)), j < len && toSelector(tokens));
+            }
+
+            matchers.push(matcher);
+          }
+        }
+
+        return elementMatcher(matchers);
+      }
+
+      function matcherFromGroupMatchers(elementMatchers, setMatchers) {
+        var bySet = setMatchers.length > 0,
+            byElement = elementMatchers.length > 0,
+            superMatcher = function (seed, context, xml, results, outermost) {
+          var elem,
+              j,
+              matcher,
+              matchedCount = 0,
+              i = "0",
+              unmatched = seed && [],
+              setMatched = [],
+              contextBackup = outermostContext,
+              // We must always have either seed elements or outermost context
+          elems = seed || byElement && Expr.find["TAG"]("*", outermost),
+              // Use integer dirruns iff this is the outermost matcher
+          dirrunsUnique = dirruns += contextBackup == null ? 1 : Math.random() || 0.1,
+              len = elems.length;
+
+          if (outermost) {
+            outermostContext = context === document || context || outermost;
+          } // Add elements passing elementMatchers directly to results
+          // Support: IE<9, Safari
+          // Tolerate NodeList properties (IE: "length"; Safari: <number>) matching elements by id
+
+
+          for (; i !== len && (elem = elems[i]) != null; i++) {
+            if (byElement && elem) {
+              j = 0;
+
+              if (!context && elem.ownerDocument !== document) {
+                setDocument(elem);
+                xml = !documentIsHTML;
+              }
+
+              while (matcher = elementMatchers[j++]) {
+                if (matcher(elem, context || document, xml)) {
+                  results.push(elem);
+                  break;
+                }
+              }
+
+              if (outermost) {
+                dirruns = dirrunsUnique;
+              }
+            } // Track unmatched elements for set filters
+
+
+            if (bySet) {
+              // They will have gone through all possible matchers
+              if (elem = !matcher && elem) {
+                matchedCount--;
+              } // Lengthen the array for every element, matched or not
+
+
+              if (seed) {
+                unmatched.push(elem);
+              }
+            }
+          } // `i` is now the count of elements visited above, and adding it to `matchedCount`
+          // makes the latter nonnegative.
+
+
+          matchedCount += i; // Apply set filters to unmatched elements
+          // NOTE: This can be skipped if there are no unmatched elements (i.e., `matchedCount`
+          // equals `i`), unless we didn't visit _any_ elements in the above loop because we have
+          // no element matchers and no seed.
+          // Incrementing an initially-string "0" `i` allows `i` to remain a string only in that
+          // case, which will result in a "00" `matchedCount` that differs from `i` but is also
+          // numerically zero.
+
+          if (bySet && i !== matchedCount) {
+            j = 0;
+
+            while (matcher = setMatchers[j++]) {
+              matcher(unmatched, setMatched, context, xml);
+            }
+
+            if (seed) {
+              // Reintegrate element matches to eliminate the need for sorting
+              if (matchedCount > 0) {
+                while (i--) {
+                  if (!(unmatched[i] || setMatched[i])) {
+                    setMatched[i] = pop.call(results);
+                  }
+                }
+              } // Discard index placeholder values to get only actual matches
+
+
+              setMatched = condense(setMatched);
+            } // Add matches to results
+
+
+            push.apply(results, setMatched); // Seedless set matches succeeding multiple successful matchers stipulate sorting
+
+            if (outermost && !seed && setMatched.length > 0 && matchedCount + setMatchers.length > 1) {
+              Sizzle.uniqueSort(results);
+            }
+          } // Override manipulation of globals by nested matchers
+
+
+          if (outermost) {
+            dirruns = dirrunsUnique;
+            outermostContext = contextBackup;
+          }
+
+          return unmatched;
+        };
+
+        return bySet ? markFunction(superMatcher) : superMatcher;
+      }
+
+      compile = Sizzle.compile = function (selector, match
+      /* Internal Use Only */
+      ) {
+        var i,
+            setMatchers = [],
+            elementMatchers = [],
+            cached = compilerCache[selector + " "];
+
+        if (!cached) {
+          // Generate a function of recursive functions that can be used to check each element
+          if (!match) {
+            match = tokenize(selector);
+          }
+
+          i = match.length;
+
+          while (i--) {
+            cached = matcherFromTokens(match[i]);
+
+            if (cached[expando]) {
+              setMatchers.push(cached);
+            } else {
+              elementMatchers.push(cached);
+            }
+          } // Cache the compiled function
+
+
+          cached = compilerCache(selector, matcherFromGroupMatchers(elementMatchers, setMatchers)); // Save selector and tokenization
+
+          cached.selector = selector;
+        }
+
+        return cached;
+      };
+      /**
+       * A low-level selection function that works with Sizzle's compiled
+       *  selector functions
+       * @param {String|Function} selector A selector or a pre-compiled
+       *  selector function built with Sizzle.compile
+       * @param {Element} context
+       * @param {Array} [results]
+       * @param {Array} [seed] A set of elements to match against
+       */
+
+
+      select = Sizzle.select = function (selector, context, results, seed) {
+        var i,
+            tokens,
+            token,
+            type,
+            find,
+            compiled = typeof selector === "function" && selector,
+            match = !seed && tokenize(selector = compiled.selector || selector);
+        results = results || []; // Try to minimize operations if there is only one selector in the list and no seed
+        // (the latter of which guarantees us context)
+
+        if (match.length === 1) {
+          // Reduce context if the leading compound selector is an ID
+          tokens = match[0] = match[0].slice(0);
+
+          if (tokens.length > 2 && (token = tokens[0]).type === "ID" && context.nodeType === 9 && documentIsHTML && Expr.relative[tokens[1].type]) {
+            context = (Expr.find["ID"](token.matches[0].replace(runescape, funescape), context) || [])[0];
+
+            if (!context) {
+              return results; // Precompiled matchers will still verify ancestry, so step up a level
+            } else if (compiled) {
+              context = context.parentNode;
+            }
+
+            selector = selector.slice(tokens.shift().value.length);
+          } // Fetch a seed set for right-to-left matching
+
+
+          i = matchExpr["needsContext"].test(selector) ? 0 : tokens.length;
+
+          while (i--) {
+            token = tokens[i]; // Abort if we hit a combinator
+
+            if (Expr.relative[type = token.type]) {
+              break;
+            }
+
+            if (find = Expr.find[type]) {
+              // Search, expanding context for leading sibling combinators
+              if (seed = find(token.matches[0].replace(runescape, funescape), rsibling.test(tokens[0].type) && testContext(context.parentNode) || context)) {
+                // If seed is empty or no tokens remain, we can return early
+                tokens.splice(i, 1);
+                selector = seed.length && toSelector(tokens);
+
+                if (!selector) {
+                  push.apply(results, seed);
+                  return results;
+                }
+
+                break;
+              }
+            }
+          }
+        } // Compile and execute a filtering function if one is not provided
+        // Provide `match` to avoid retokenization if we modified the selector above
+
+
+        (compiled || compile(selector, match))(seed, context, !documentIsHTML, results, !context || rsibling.test(selector) && testContext(context.parentNode) || context);
+        return results;
+      }; // One-time assignments
+      // Sort stability
+
+
+      support.sortStable = expando.split("").sort(sortOrder).join("") === expando; // Support: Chrome 14-35+
+      // Always assume duplicates if they aren't passed to the comparison function
+
+      support.detectDuplicates = !!hasDuplicate; // Initialize against the default document
+
+      setDocument();
+      return Sizzle;
+    }(window);
+
+    jQuery.find = Sizzle;
+    jQuery.expr = Sizzle.selectors; // Deprecated
+
+    jQuery.expr[":"] = jQuery.expr.pseudos;
+    jQuery.uniqueSort = jQuery.unique = Sizzle.uniqueSort;
+    jQuery.text = Sizzle.getText;
+    jQuery.isXMLDoc = Sizzle.isXML;
+    jQuery.contains = Sizzle.contains;
+    jQuery.escapeSelector = Sizzle.escape;
+
+    var dir = function (elem, dir, until) {
+      var matched = [],
+          truncate = until !== undefined;
+
+      while ((elem = elem[dir]) && elem.nodeType !== 9) {
+        if (elem.nodeType === 1) {
+          if (truncate && jQuery(elem).is(until)) {
+            break;
+          }
+
+          matched.push(elem);
+        }
+      }
+
+      return matched;
+    };
+
+    var siblings = function (n, elem) {
+      var matched = [];
+
+      for (; n; n = n.nextSibling) {
+        if (n.nodeType === 1 && n !== elem) {
+          matched.push(n);
+        }
+      }
+
+      return matched;
+    };
+
+    var rneedsContext = jQuery.expr.match.needsContext;
+
+    function nodeName(elem, name) {
+      return elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase();
+    }
+
+    var rsingleTag = /^<([a-z][^\/\0>:\x20\t\r\n\f]*)[\x20\t\r\n\f]*\/?>(?:<\/\1>|)$/i; // Implement the identical functionality for filter and not
+
+    function winnow(elements, qualifier, not) {
+      if (isFunction(qualifier)) {
+        return jQuery.grep(elements, function (elem, i) {
+          return !!qualifier.call(elem, i, elem) !== not;
+        });
+      } // Single element
+
+
+      if (qualifier.nodeType) {
+        return jQuery.grep(elements, function (elem) {
+          return elem === qualifier !== not;
+        });
+      } // Arraylike of elements (jQuery, arguments, Array)
+
+
+      if (typeof qualifier !== "string") {
+        return jQuery.grep(elements, function (elem) {
+          return indexOf$1.call(qualifier, elem) > -1 !== not;
+        });
+      } // Filtered directly for both simple and complex selectors
+
+
+      return jQuery.filter(qualifier, elements, not);
+    }
+
+    jQuery.filter = function (expr, elems, not) {
+      var elem = elems[0];
+
+      if (not) {
+        expr = ":not(" + expr + ")";
+      }
+
+      if (elems.length === 1 && elem.nodeType === 1) {
+        return jQuery.find.matchesSelector(elem, expr) ? [elem] : [];
+      }
+
+      return jQuery.find.matches(expr, jQuery.grep(elems, function (elem) {
+        return elem.nodeType === 1;
+      }));
+    };
+
+    jQuery.fn.extend({
+      find: function (selector) {
+        var i,
+            ret,
+            len = this.length,
+            self = this;
+
+        if (typeof selector !== "string") {
+          return this.pushStack(jQuery(selector).filter(function () {
+            for (i = 0; i < len; i++) {
+              if (jQuery.contains(self[i], this)) {
+                return true;
+              }
+            }
+          }));
+        }
+
+        ret = this.pushStack([]);
+
+        for (i = 0; i < len; i++) {
+          jQuery.find(selector, self[i], ret);
+        }
+
+        return len > 1 ? jQuery.uniqueSort(ret) : ret;
+      },
+      filter: function (selector) {
+        return this.pushStack(winnow(this, selector || [], false));
+      },
+      not: function (selector) {
+        return this.pushStack(winnow(this, selector || [], true));
+      },
+      is: function (selector) {
+        return !!winnow(this, // If this is a positional/relative selector, check membership in the returned set
+        // so $("p:first").is("p:last") won't return true for a doc with two "p".
+        typeof selector === "string" && rneedsContext.test(selector) ? jQuery(selector) : selector || [], false).length;
+      }
+    }); // Initialize a jQuery object
+    // A central reference to the root jQuery(document)
+
+    var rootjQuery,
+        // A simple way to check for HTML strings
+    // Prioritize #id over <tag> to avoid XSS via location.hash (#9521)
+    // Strict HTML recognition (#11290: must start with <)
+    // Shortcut simple #id case for speed
+    rquickExpr = /^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]+))$/,
+        init$2 = jQuery.fn.init = function (selector, context, root) {
+      var match, elem; // HANDLE: $(""), $(null), $(undefined), $(false)
+
+      if (!selector) {
+        return this;
+      } // Method init() accepts an alternate rootjQuery
+      // so migrate can support jQuery.sub (gh-2101)
+
+
+      root = root || rootjQuery; // Handle HTML strings
+
+      if (typeof selector === "string") {
+        if (selector[0] === "<" && selector[selector.length - 1] === ">" && selector.length >= 3) {
+          // Assume that strings that start and end with <> are HTML and skip the regex check
+          match = [null, selector, null];
+        } else {
+          match = rquickExpr.exec(selector);
+        } // Match html or make sure no context is specified for #id
+
+
+        if (match && (match[1] || !context)) {
+          // HANDLE: $(html) -> $(array)
+          if (match[1]) {
+            context = context instanceof jQuery ? context[0] : context; // Option to run scripts is true for back-compat
+            // Intentionally let the error be thrown if parseHTML is not present
+
+            jQuery.merge(this, jQuery.parseHTML(match[1], context && context.nodeType ? context.ownerDocument || context : document$2, true)); // HANDLE: $(html, props)
+
+            if (rsingleTag.test(match[1]) && jQuery.isPlainObject(context)) {
+              for (match in context) {
+                // Properties of context are called as methods if possible
+                if (isFunction(this[match])) {
+                  this[match](context[match]); // ...and otherwise set as attributes
+                } else {
+                  this.attr(match, context[match]);
+                }
+              }
+            }
+
+            return this; // HANDLE: $(#id)
+          } else {
+            elem = document$2.getElementById(match[2]);
+
+            if (elem) {
+              // Inject the element directly into the jQuery object
+              this[0] = elem;
+              this.length = 1;
+            }
+
+            return this;
+          } // HANDLE: $(expr, $(...))
+
+        } else if (!context || context.jquery) {
+          return (context || root).find(selector); // HANDLE: $(expr, context)
+          // (which is just equivalent to: $(context).find(expr)
+        } else {
+          return this.constructor(context).find(selector);
+        } // HANDLE: $(DOMElement)
+
+      } else if (selector.nodeType) {
+        this[0] = selector;
+        this.length = 1;
+        return this; // HANDLE: $(function)
+        // Shortcut for document ready
+      } else if (isFunction(selector)) {
+        return root.ready !== undefined ? root.ready(selector) : // Execute immediately if ready is not present
+        selector(jQuery);
+      }
+
+      return jQuery.makeArray(selector, this);
+    }; // Give the init function the jQuery prototype for later instantiation
+
+
+    init$2.prototype = jQuery.fn; // Initialize central reference
+
+    rootjQuery = jQuery(document$2);
+    var rparentsprev = /^(?:parents|prev(?:Until|All))/,
+        // Methods guaranteed to produce a unique set when starting from a unique set
+    guaranteedUnique = {
+      children: true,
+      contents: true,
+      next: true,
+      prev: true
+    };
+    jQuery.fn.extend({
+      has: function (target) {
+        var targets = jQuery(target, this),
+            l = targets.length;
+        return this.filter(function () {
+          var i = 0;
+
+          for (; i < l; i++) {
+            if (jQuery.contains(this, targets[i])) {
+              return true;
+            }
+          }
+        });
+      },
+      closest: function (selectors, context) {
+        var cur,
+            i = 0,
+            l = this.length,
+            matched = [],
+            targets = typeof selectors !== "string" && jQuery(selectors); // Positional selectors never match, since there's no _selection_ context
+
+        if (!rneedsContext.test(selectors)) {
+          for (; i < l; i++) {
+            for (cur = this[i]; cur && cur !== context; cur = cur.parentNode) {
+              // Always skip document fragments
+              if (cur.nodeType < 11 && (targets ? targets.index(cur) > -1 : // Don't pass non-elements to Sizzle
+              cur.nodeType === 1 && jQuery.find.matchesSelector(cur, selectors))) {
+                matched.push(cur);
+                break;
+              }
+            }
+          }
+        }
+
+        return this.pushStack(matched.length > 1 ? jQuery.uniqueSort(matched) : matched);
+      },
+      // Determine the position of an element within the set
+      index: function (elem) {
+        // No argument, return index in parent
+        if (!elem) {
+          return this[0] && this[0].parentNode ? this.first().prevAll().length : -1;
+        } // Index in selector
+
+
+        if (typeof elem === "string") {
+          return indexOf$1.call(jQuery(elem), this[0]);
+        } // Locate the position of the desired element
+
+
+        return indexOf$1.call(this, // If it receives a jQuery object, the first element is used
+        elem.jquery ? elem[0] : elem);
+      },
+      add: function (selector, context) {
+        return this.pushStack(jQuery.uniqueSort(jQuery.merge(this.get(), jQuery(selector, context))));
+      },
+      addBack: function (selector) {
+        return this.add(selector == null ? this.prevObject : this.prevObject.filter(selector));
+      }
+    });
+
+    function sibling(cur, dir) {
+      while ((cur = cur[dir]) && cur.nodeType !== 1) {}
+
+      return cur;
+    }
+
+    jQuery.each({
+      parent: function (elem) {
+        var parent = elem.parentNode;
+        return parent && parent.nodeType !== 11 ? parent : null;
+      },
+      parents: function (elem) {
+        return dir(elem, "parentNode");
+      },
+      parentsUntil: function (elem, i, until) {
+        return dir(elem, "parentNode", until);
+      },
+      next: function (elem) {
+        return sibling(elem, "nextSibling");
+      },
+      prev: function (elem) {
+        return sibling(elem, "previousSibling");
+      },
+      nextAll: function (elem) {
+        return dir(elem, "nextSibling");
+      },
+      prevAll: function (elem) {
+        return dir(elem, "previousSibling");
+      },
+      nextUntil: function (elem, i, until) {
+        return dir(elem, "nextSibling", until);
+      },
+      prevUntil: function (elem, i, until) {
+        return dir(elem, "previousSibling", until);
+      },
+      siblings: function (elem) {
+        return siblings((elem.parentNode || {}).firstChild, elem);
+      },
+      children: function (elem) {
+        return siblings(elem.firstChild);
+      },
+      contents: function (elem) {
+        if (nodeName(elem, "iframe")) {
+          return elem.contentDocument;
+        } // Support: IE 9 - 11 only, iOS 7 only, Android Browser <=4.3 only
+        // Treat the template element as a regular one in browsers that
+        // don't support it.
+
+
+        if (nodeName(elem, "template")) {
+          elem = elem.content || elem;
+        }
+
+        return jQuery.merge([], elem.childNodes);
+      }
+    }, function (name, fn) {
+      jQuery.fn[name] = function (until, selector) {
+        var matched = jQuery.map(this, fn, until);
+
+        if (name.slice(-5) !== "Until") {
+          selector = until;
+        }
+
+        if (selector && typeof selector === "string") {
+          matched = jQuery.filter(selector, matched);
+        }
+
+        if (this.length > 1) {
+          // Remove duplicates
+          if (!guaranteedUnique[name]) {
+            jQuery.uniqueSort(matched);
+          } // Reverse order for parents* and prev-derivatives
+
+
+          if (rparentsprev.test(name)) {
+            matched.reverse();
+          }
+        }
+
+        return this.pushStack(matched);
+      };
+    });
+    var rnothtmlwhite = /[^\x20\t\r\n\f]+/g; // Convert String-formatted options into Object-formatted ones
+
+    function createOptions(options) {
+      var object = {};
+      jQuery.each(options.match(rnothtmlwhite) || [], function (_, flag) {
+        object[flag] = true;
+      });
+      return object;
+    }
+    /*
+     * Create a callback list using the following parameters:
+     *
+     *	options: an optional list of space-separated options that will change how
+     *			the callback list behaves or a more traditional option object
+     *
+     * By default a callback list will act like an event callback list and can be
+     * "fired" multiple times.
+     *
+     * Possible options:
+     *
+     *	once:			will ensure the callback list can only be fired once (like a Deferred)
+     *
+     *	memory:			will keep track of previous values and will call any callback added
+     *					after the list has been fired right away with the latest "memorized"
+     *					values (like a Deferred)
+     *
+     *	unique:			will ensure a callback can only be added once (no duplicate in the list)
+     *
+     *	stopOnFalse:	interrupt callings when a callback returns false
+     *
+     */
+
+
+    jQuery.Callbacks = function (options) {
+      // Convert options from String-formatted to Object-formatted if needed
+      // (we check in cache first)
+      options = typeof options === "string" ? createOptions(options) : jQuery.extend({}, options);
+
+      var // Flag to know if list is currently firing
+      firing,
+          // Last fire value for non-forgettable lists
+      memory,
+          // Flag to know if list was already fired
+      fired,
+          // Flag to prevent firing
+      locked,
+          // Actual callback list
+      list = [],
+          // Queue of execution data for repeatable lists
+      queue = [],
+          // Index of currently firing callback (modified by add/remove as needed)
+      firingIndex = -1,
+          // Fire callbacks
+      fire = function () {
+        // Enforce single-firing
+        locked = locked || options.once; // Execute callbacks for all pending executions,
+        // respecting firingIndex overrides and runtime changes
+
+        fired = firing = true;
+
+        for (; queue.length; firingIndex = -1) {
+          memory = queue.shift();
+
+          while (++firingIndex < list.length) {
+            // Run callback and check for early termination
+            if (list[firingIndex].apply(memory[0], memory[1]) === false && options.stopOnFalse) {
+              // Jump to end and forget the data so .add doesn't re-fire
+              firingIndex = list.length;
+              memory = false;
+            }
+          }
+        } // Forget the data if we're done with it
+
+
+        if (!options.memory) {
+          memory = false;
+        }
+
+        firing = false; // Clean up if we're done firing for good
+
+        if (locked) {
+          // Keep an empty list if we have data for future add calls
+          if (memory) {
+            list = []; // Otherwise, this object is spent
+          } else {
+            list = "";
+          }
+        }
+      },
+          // Actual Callbacks object
+      self = {
+        // Add a callback or a collection of callbacks to the list
+        add: function () {
+          if (list) {
+            // If we have memory from a past run, we should fire after adding
+            if (memory && !firing) {
+              firingIndex = list.length - 1;
+              queue.push(memory);
+            }
+
+            (function add(args) {
+              jQuery.each(args, function (_, arg) {
+                if (isFunction(arg)) {
+                  if (!options.unique || !self.has(arg)) {
+                    list.push(arg);
+                  }
+                } else if (arg && arg.length && toType(arg) !== "string") {
+                  // Inspect recursively
+                  add(arg);
+                }
+              });
+            })(arguments);
+
+            if (memory && !firing) {
+              fire();
+            }
+          }
+
+          return this;
+        },
+        // Remove a callback from the list
+        remove: function () {
+          jQuery.each(arguments, function (_, arg) {
+            var index;
+
+            while ((index = jQuery.inArray(arg, list, index)) > -1) {
+              list.splice(index, 1); // Handle firing indexes
+
+              if (index <= firingIndex) {
+                firingIndex--;
+              }
+            }
+          });
+          return this;
+        },
+        // Check if a given callback is in the list.
+        // If no argument is given, return whether or not list has callbacks attached.
+        has: function (fn) {
+          return fn ? jQuery.inArray(fn, list) > -1 : list.length > 0;
+        },
+        // Remove all callbacks from the list
+        empty: function () {
+          if (list) {
+            list = [];
+          }
+
+          return this;
+        },
+        // Disable .fire and .add
+        // Abort any current/pending executions
+        // Clear all callbacks and values
+        disable: function () {
+          locked = queue = [];
+          list = memory = "";
+          return this;
+        },
+        disabled: function () {
+          return !list;
+        },
+        // Disable .fire
+        // Also disable .add unless we have memory (since it would have no effect)
+        // Abort any pending executions
+        lock: function () {
+          locked = queue = [];
+
+          if (!memory && !firing) {
+            list = memory = "";
+          }
+
+          return this;
+        },
+        locked: function () {
+          return !!locked;
+        },
+        // Call all callbacks with the given context and arguments
+        fireWith: function (context, args) {
+          if (!locked) {
+            args = args || [];
+            args = [context, args.slice ? args.slice() : args];
+            queue.push(args);
+
+            if (!firing) {
+              fire();
+            }
+          }
+
+          return this;
+        },
+        // Call all the callbacks with the given arguments
+        fire: function () {
+          self.fireWith(this, arguments);
+          return this;
+        },
+        // To know if the callbacks have already been called at least once
+        fired: function () {
+          return !!fired;
+        }
+      };
+
+      return self;
+    };
+
+    function Identity(v) {
+      return v;
+    }
+
+    function Thrower(ex) {
+      throw ex;
+    }
+
+    function adoptValue(value, resolve, reject, noValue) {
+      var method;
+
+      try {
+        // Check for promise aspect first to privilege synchronous behavior
+        if (value && isFunction(method = value.promise)) {
+          method.call(value).done(resolve).fail(reject); // Other thenables
+        } else if (value && isFunction(method = value.then)) {
+          method.call(value, resolve, reject); // Other non-thenables
+        } else {
+          // Control `resolve` arguments by letting Array#slice cast boolean `noValue` to integer:
+          // * false: [ value ].slice( 0 ) => resolve( value )
+          // * true: [ value ].slice( 1 ) => resolve()
+          resolve.apply(undefined, [value].slice(noValue));
+        } // For Promises/A+, convert exceptions into rejections
+        // Since jQuery.when doesn't unwrap thenables, we can skip the extra checks appearing in
+        // Deferred#then to conditionally suppress rejection.
+
+      } catch (value) {
+        // Support: Android 4.0 only
+        // Strict mode functions invoked without .call/.apply get global-object context
+        reject.apply(undefined, [value]);
+      }
+    }
+
+    jQuery.extend({
+      Deferred: function (func) {
+        var tuples = [// action, add listener, callbacks,
+        // ... .then handlers, argument index, [final state]
+        ["notify", "progress", jQuery.Callbacks("memory"), jQuery.Callbacks("memory"), 2], ["resolve", "done", jQuery.Callbacks("once memory"), jQuery.Callbacks("once memory"), 0, "resolved"], ["reject", "fail", jQuery.Callbacks("once memory"), jQuery.Callbacks("once memory"), 1, "rejected"]],
+            state = "pending",
+            promise = {
+          state: function () {
+            return state;
+          },
+          always: function () {
+            deferred.done(arguments).fail(arguments);
+            return this;
+          },
+          "catch": function (fn) {
+            return promise.then(null, fn);
+          },
+          // Keep pipe for back-compat
+          pipe: function () {
+            var fns = arguments;
+            return jQuery.Deferred(function (newDefer) {
+              jQuery.each(tuples, function (i, tuple) {
+                // Map tuples (progress, done, fail) to arguments (done, fail, progress)
+                var fn = isFunction(fns[tuple[4]]) && fns[tuple[4]]; // deferred.progress(function() { bind to newDefer or newDefer.notify })
+                // deferred.done(function() { bind to newDefer or newDefer.resolve })
+                // deferred.fail(function() { bind to newDefer or newDefer.reject })
+
+                deferred[tuple[1]](function () {
+                  var returned = fn && fn.apply(this, arguments);
+
+                  if (returned && isFunction(returned.promise)) {
+                    returned.promise().progress(newDefer.notify).done(newDefer.resolve).fail(newDefer.reject);
+                  } else {
+                    newDefer[tuple[0] + "With"](this, fn ? [returned] : arguments);
+                  }
+                });
+              });
+              fns = null;
+            }).promise();
+          },
+          then: function (onFulfilled, onRejected, onProgress) {
+            var maxDepth = 0;
+
+            function resolve(depth, deferred, handler, special) {
+              return function () {
+                var that = this,
+                    args = arguments,
+                    mightThrow = function () {
+                  var returned, then; // Support: Promises/A+ section 2.3.3.3.3
+                  // https://promisesaplus.com/#point-59
+                  // Ignore double-resolution attempts
+
+                  if (depth < maxDepth) {
+                    return;
+                  }
+
+                  returned = handler.apply(that, args); // Support: Promises/A+ section 2.3.1
+                  // https://promisesaplus.com/#point-48
+
+                  if (returned === deferred.promise()) {
+                    throw new TypeError("Thenable self-resolution");
+                  } // Support: Promises/A+ sections 2.3.3.1, 3.5
+                  // https://promisesaplus.com/#point-54
+                  // https://promisesaplus.com/#point-75
+                  // Retrieve `then` only once
+
+
+                  then = returned && (typeof returned === "object" || typeof returned === "function") && returned.then; // Handle a returned thenable
+
+                  if (isFunction(then)) {
+                    // Special processors (notify) just wait for resolution
+                    if (special) {
+                      then.call(returned, resolve(maxDepth, deferred, Identity, special), resolve(maxDepth, deferred, Thrower, special)); // Normal processors (resolve) also hook into progress
+                    } else {
+                      // ...and disregard older resolution values
+                      maxDepth++;
+                      then.call(returned, resolve(maxDepth, deferred, Identity, special), resolve(maxDepth, deferred, Thrower, special), resolve(maxDepth, deferred, Identity, deferred.notifyWith));
+                    } // Handle all other returned values
+
+                  } else {
+                    // Only substitute handlers pass on context
+                    // and multiple values (non-spec behavior)
+                    if (handler !== Identity) {
+                      that = undefined;
+                      args = [returned];
+                    } // Process the value(s)
+                    // Default process is resolve
+
+
+                    (special || deferred.resolveWith)(that, args);
+                  }
+                },
+                    // Only normal processors (resolve) catch and reject exceptions
+                process = special ? mightThrow : function () {
+                  try {
+                    mightThrow();
+                  } catch (e) {
+                    if (jQuery.Deferred.exceptionHook) {
+                      jQuery.Deferred.exceptionHook(e, process.stackTrace);
+                    } // Support: Promises/A+ section 2.3.3.3.4.1
+                    // https://promisesaplus.com/#point-61
+                    // Ignore post-resolution exceptions
+
+
+                    if (depth + 1 >= maxDepth) {
+                      // Only substitute handlers pass on context
+                      // and multiple values (non-spec behavior)
+                      if (handler !== Thrower) {
+                        that = undefined;
+                        args = [e];
+                      }
+
+                      deferred.rejectWith(that, args);
+                    }
+                  }
+                }; // Support: Promises/A+ section 2.3.3.3.1
+                // https://promisesaplus.com/#point-57
+                // Re-resolve promises immediately to dodge false rejection from
+                // subsequent errors
+
+
+                if (depth) {
+                  process();
+                } else {
+                  // Call an optional hook to record the stack, in case of exception
+                  // since it's otherwise lost when execution goes async
+                  if (jQuery.Deferred.getStackHook) {
+                    process.stackTrace = jQuery.Deferred.getStackHook();
+                  }
+
+                  window.setTimeout(process);
+                }
+              };
+            }
+
+            return jQuery.Deferred(function (newDefer) {
+              // progress_handlers.add( ... )
+              tuples[0][3].add(resolve(0, newDefer, isFunction(onProgress) ? onProgress : Identity, newDefer.notifyWith)); // fulfilled_handlers.add( ... )
+
+              tuples[1][3].add(resolve(0, newDefer, isFunction(onFulfilled) ? onFulfilled : Identity)); // rejected_handlers.add( ... )
+
+              tuples[2][3].add(resolve(0, newDefer, isFunction(onRejected) ? onRejected : Thrower));
+            }).promise();
+          },
+          // Get a promise for this deferred
+          // If obj is provided, the promise aspect is added to the object
+          promise: function (obj) {
+            return obj != null ? jQuery.extend(obj, promise) : promise;
+          }
+        },
+            deferred = {}; // Add list-specific methods
+
+        jQuery.each(tuples, function (i, tuple) {
+          var list = tuple[2],
+              stateString = tuple[5]; // promise.progress = list.add
+          // promise.done = list.add
+          // promise.fail = list.add
+
+          promise[tuple[1]] = list.add; // Handle state
+
+          if (stateString) {
+            list.add(function () {
+              // state = "resolved" (i.e., fulfilled)
+              // state = "rejected"
+              state = stateString;
+            }, // rejected_callbacks.disable
+            // fulfilled_callbacks.disable
+            tuples[3 - i][2].disable, // rejected_handlers.disable
+            // fulfilled_handlers.disable
+            tuples[3 - i][3].disable, // progress_callbacks.lock
+            tuples[0][2].lock, // progress_handlers.lock
+            tuples[0][3].lock);
+          } // progress_handlers.fire
+          // fulfilled_handlers.fire
+          // rejected_handlers.fire
+
+
+          list.add(tuple[3].fire); // deferred.notify = function() { deferred.notifyWith(...) }
+          // deferred.resolve = function() { deferred.resolveWith(...) }
+          // deferred.reject = function() { deferred.rejectWith(...) }
+
+          deferred[tuple[0]] = function () {
+            deferred[tuple[0] + "With"](this === deferred ? undefined : this, arguments);
+            return this;
+          }; // deferred.notifyWith = list.fireWith
+          // deferred.resolveWith = list.fireWith
+          // deferred.rejectWith = list.fireWith
+
+
+          deferred[tuple[0] + "With"] = list.fireWith;
+        }); // Make the deferred a promise
+
+        promise.promise(deferred); // Call given func if any
+
+        if (func) {
+          func.call(deferred, deferred);
+        } // All done!
+
+
+        return deferred;
+      },
+      // Deferred helper
+      when: function (singleValue) {
+        var // count of uncompleted subordinates
+        remaining = arguments.length,
+            // count of unprocessed arguments
+        i = remaining,
+            // subordinate fulfillment data
+        resolveContexts = Array(i),
+            resolveValues = slice.call(arguments),
+            // the master Deferred
+        master = jQuery.Deferred(),
+            // subordinate callback factory
+        updateFunc = function (i) {
+          return function (value) {
+            resolveContexts[i] = this;
+            resolveValues[i] = arguments.length > 1 ? slice.call(arguments) : value;
+
+            if (! --remaining) {
+              master.resolveWith(resolveContexts, resolveValues);
+            }
+          };
+        }; // Single- and empty arguments are adopted like Promise.resolve
+
+
+        if (remaining <= 1) {
+          adoptValue(singleValue, master.done(updateFunc(i)).resolve, master.reject, !remaining); // Use .then() to unwrap secondary thenables (cf. gh-3000)
+
+          if (master.state() === "pending" || isFunction(resolveValues[i] && resolveValues[i].then)) {
+            return master.then();
+          }
+        } // Multiple arguments are aggregated like Promise.all array elements
+
+
+        while (i--) {
+          adoptValue(resolveValues[i], updateFunc(i), master.reject);
+        }
+
+        return master.promise();
+      }
+    }); // These usually indicate a programmer mistake during development,
+    // warn about them ASAP rather than swallowing them by default.
+
+    var rerrorNames = /^(Eval|Internal|Range|Reference|Syntax|Type|URI)Error$/;
+
+    jQuery.Deferred.exceptionHook = function (error, stack) {
+      // Support: IE 8 - 9 only
+      // Console exists when dev tools are open, which can happen at any time
+      if (window.console && window.console.warn && error && rerrorNames.test(error.name)) {
+        window.console.warn("jQuery.Deferred exception: " + error.message, error.stack, stack);
+      }
+    };
+
+    jQuery.readyException = function (error) {
+      window.setTimeout(function () {
+        throw error;
+      });
+    }; // The deferred used on DOM ready
+
+
+    var readyList = jQuery.Deferred();
+
+    jQuery.fn.ready = function (fn) {
+      readyList.then(fn) // Wrap jQuery.readyException in a function so that the lookup
+      // happens at the time of error handling instead of callback
+      // registration.
+      .catch(function (error) {
+        jQuery.readyException(error);
+      });
+      return this;
+    };
+
+    jQuery.extend({
+      // Is the DOM ready to be used? Set to true once it occurs.
+      isReady: false,
+      // A counter to track how many items to wait for before
+      // the ready event fires. See #6781
+      readyWait: 1,
+      // Handle when the DOM is ready
+      ready: function (wait) {
+        // Abort if there are pending holds or we're already ready
+        if (wait === true ? --jQuery.readyWait : jQuery.isReady) {
+          return;
+        } // Remember that the DOM is ready
+
+
+        jQuery.isReady = true; // If a normal DOM Ready event fired, decrement, and wait if need be
+
+        if (wait !== true && --jQuery.readyWait > 0) {
+          return;
+        } // If there are functions bound, to execute
+
+
+        readyList.resolveWith(document$2, [jQuery]);
+      }
+    });
+    jQuery.ready.then = readyList.then; // The ready event handler and self cleanup method
+
+    function completed() {
+      document$2.removeEventListener("DOMContentLoaded", completed);
+      window.removeEventListener("load", completed);
+      jQuery.ready();
+    } // Catch cases where $(document).ready() is called
+    // after the browser event has already occurred.
+    // Support: IE <=9 - 10 only
+    // Older IE sometimes signals "interactive" too soon
+
+
+    if (document$2.readyState === "complete" || document$2.readyState !== "loading" && !document$2.documentElement.doScroll) {
+      // Handle it asynchronously to allow scripts the opportunity to delay ready
+      window.setTimeout(jQuery.ready);
+    } else {
+      // Use the handy event callback
+      document$2.addEventListener("DOMContentLoaded", completed); // A fallback to window.onload, that will always work
+
+      window.addEventListener("load", completed);
+    } // Multifunctional method to get and set values of a collection
+    // The value/s can optionally be executed if it's a function
+
+
+    var access = function (elems, fn, key, value, chainable, emptyGet, raw) {
+      var i = 0,
+          len = elems.length,
+          bulk = key == null; // Sets many values
+
+      if (toType(key) === "object") {
+        chainable = true;
+
+        for (i in key) {
+          access(elems, fn, i, key[i], true, emptyGet, raw);
+        } // Sets one value
+
+      } else if (value !== undefined) {
+        chainable = true;
+
+        if (!isFunction(value)) {
+          raw = true;
+        }
+
+        if (bulk) {
+          // Bulk operations run against the entire set
+          if (raw) {
+            fn.call(elems, value);
+            fn = null; // ...except when executing function values
+          } else {
+            bulk = fn;
+
+            fn = function (elem, key, value) {
+              return bulk.call(jQuery(elem), value);
+            };
+          }
+        }
+
+        if (fn) {
+          for (; i < len; i++) {
+            fn(elems[i], key, raw ? value : value.call(elems[i], i, fn(elems[i], key)));
+          }
+        }
+      }
+
+      if (chainable) {
+        return elems;
+      } // Gets
+
+
+      if (bulk) {
+        return fn.call(elems);
+      }
+
+      return len ? fn(elems[0], key) : emptyGet;
+    }; // Matches dashed string for camelizing
+
+
+    var rmsPrefix = /^-ms-/,
+        rdashAlpha = /-([a-z])/g; // Used by camelCase as callback to replace()
+
+    function fcamelCase(all, letter) {
+      return letter.toUpperCase();
+    } // Convert dashed to camelCase; used by the css and data modules
+    // Support: IE <=9 - 11, Edge 12 - 15
+    // Microsoft forgot to hump their vendor prefix (#9572)
+
+
+    function camelCase(string) {
+      return string.replace(rmsPrefix, "ms-").replace(rdashAlpha, fcamelCase);
+    }
+
+    var acceptData = function (owner) {
+      // Accepts only:
+      //  - Node
+      //    - Node.ELEMENT_NODE
+      //    - Node.DOCUMENT_NODE
+      //  - Object
+      //    - Any
+      return owner.nodeType === 1 || owner.nodeType === 9 || !+owner.nodeType;
+    };
+
+    function Data() {
+      this.expando = jQuery.expando + Data.uid++;
+    }
+
+    Data.uid = 1;
+    Data.prototype = {
+      cache: function (owner) {
+        // Check if the owner object already has a cache
+        var value = owner[this.expando]; // If not, create one
+
+        if (!value) {
+          value = {}; // We can accept data for non-element nodes in modern browsers,
+          // but we should not, see #8335.
+          // Always return an empty object.
+
+          if (acceptData(owner)) {
+            // If it is a node unlikely to be stringify-ed or looped over
+            // use plain assignment
+            if (owner.nodeType) {
+              owner[this.expando] = value; // Otherwise secure it in a non-enumerable property
+              // configurable must be true to allow the property to be
+              // deleted when data is removed
+            } else {
+              Object.defineProperty(owner, this.expando, {
+                value: value,
+                configurable: true
+              });
+            }
+          }
+        }
+
+        return value;
+      },
+      set: function (owner, data, value) {
+        var prop,
+            cache = this.cache(owner); // Handle: [ owner, key, value ] args
+        // Always use camelCase key (gh-2257)
+
+        if (typeof data === "string") {
+          cache[camelCase(data)] = value; // Handle: [ owner, { properties } ] args
+        } else {
+          // Copy the properties one-by-one to the cache object
+          for (prop in data) {
+            cache[camelCase(prop)] = data[prop];
+          }
+        }
+
+        return cache;
+      },
+      get: function (owner, key) {
+        return key === undefined ? this.cache(owner) : // Always use camelCase key (gh-2257)
+        owner[this.expando] && owner[this.expando][camelCase(key)];
+      },
+      access: function (owner, key, value) {
+        // In cases where either:
+        //
+        //   1. No key was specified
+        //   2. A string key was specified, but no value provided
+        //
+        // Take the "read" path and allow the get method to determine
+        // which value to return, respectively either:
+        //
+        //   1. The entire cache object
+        //   2. The data stored at the key
+        //
+        if (key === undefined || key && typeof key === "string" && value === undefined) {
+          return this.get(owner, key);
+        } // When the key is not a string, or both a key and value
+        // are specified, set or extend (existing objects) with either:
+        //
+        //   1. An object of properties
+        //   2. A key and value
+        //
+
+
+        this.set(owner, key, value); // Since the "set" path can have two possible entry points
+        // return the expected data based on which path was taken[*]
+
+        return value !== undefined ? value : key;
+      },
+      remove: function (owner, key) {
+        var i,
+            cache = owner[this.expando];
+
+        if (cache === undefined) {
+          return;
+        }
+
+        if (key !== undefined) {
+          // Support array or space separated string of keys
+          if (Array.isArray(key)) {
+            // If key is an array of keys...
+            // We always set camelCase keys, so remove that.
+            key = key.map(camelCase);
+          } else {
+            key = camelCase(key); // If a key with the spaces exists, use it.
+            // Otherwise, create an array by matching non-whitespace
+
+            key = key in cache ? [key] : key.match(rnothtmlwhite) || [];
+          }
+
+          i = key.length;
+
+          while (i--) {
+            delete cache[key[i]];
+          }
+        } // Remove the expando if there's no more data
+
+
+        if (key === undefined || jQuery.isEmptyObject(cache)) {
+          // Support: Chrome <=35 - 45
+          // Webkit & Blink performance suffers when deleting properties
+          // from DOM nodes, so set to undefined instead
+          // https://bugs.chromium.org/p/chromium/issues/detail?id=378607 (bug restricted)
+          if (owner.nodeType) {
+            owner[this.expando] = undefined;
+          } else {
+            delete owner[this.expando];
+          }
+        }
+      },
+      hasData: function (owner) {
+        var cache = owner[this.expando];
+        return cache !== undefined && !jQuery.isEmptyObject(cache);
+      }
+    };
+    var dataPriv = new Data();
+    var dataUser = new Data(); //	Implementation Summary
+    //
+    //	1. Enforce API surface and semantic compatibility with 1.9.x branch
+    //	2. Improve the module's maintainability by reducing the storage
+    //		paths to a single mechanism.
+    //	3. Use the same single mechanism to support "private" and "user" data.
+    //	4. _Never_ expose "private" data to user code (TODO: Drop _data, _removeData)
+    //	5. Avoid exposing implementation details on user objects (eg. expando properties)
+    //	6. Provide a clear path for implementation upgrade to WeakMap in 2014
+
+    var rbrace = /^(?:\{[\w\W]*\}|\[[\w\W]*\])$/,
+        rmultiDash = /[A-Z]/g;
+
+    function getData(data) {
+      if (data === "true") {
+        return true;
+      }
+
+      if (data === "false") {
+        return false;
+      }
+
+      if (data === "null") {
+        return null;
+      } // Only convert to a number if it doesn't change the string
+
+
+      if (data === +data + "") {
+        return +data;
+      }
+
+      if (rbrace.test(data)) {
+        return JSON.parse(data);
+      }
+
+      return data;
+    }
+
+    function dataAttr(elem, key, data) {
+      var name; // If nothing was found internally, try to fetch any
+      // data from the HTML5 data-* attribute
+
+      if (data === undefined && elem.nodeType === 1) {
+        name = "data-" + key.replace(rmultiDash, "-$&").toLowerCase();
+        data = elem.getAttribute(name);
+
+        if (typeof data === "string") {
+          try {
+            data = getData(data);
+          } catch (e) {} // Make sure we set the data so it isn't changed later
+
+
+          dataUser.set(elem, key, data);
+        } else {
+          data = undefined;
+        }
+      }
+
+      return data;
+    }
+
+    jQuery.extend({
+      hasData: function (elem) {
+        return dataUser.hasData(elem) || dataPriv.hasData(elem);
+      },
+      data: function (elem, name, data) {
+        return dataUser.access(elem, name, data);
+      },
+      removeData: function (elem, name) {
+        dataUser.remove(elem, name);
+      },
+      // TODO: Now that all calls to _data and _removeData have been replaced
+      // with direct calls to dataPriv methods, these can be deprecated.
+      _data: function (elem, name, data) {
+        return dataPriv.access(elem, name, data);
+      },
+      _removeData: function (elem, name) {
+        dataPriv.remove(elem, name);
+      }
+    });
+    jQuery.fn.extend({
+      data: function (key, value) {
+        var i,
+            name,
+            data,
+            elem = this[0],
+            attrs = elem && elem.attributes; // Gets all values
+
+        if (key === undefined) {
+          if (this.length) {
+            data = dataUser.get(elem);
+
+            if (elem.nodeType === 1 && !dataPriv.get(elem, "hasDataAttrs")) {
+              i = attrs.length;
+
+              while (i--) {
+                // Support: IE 11 only
+                // The attrs elements can be null (#14894)
+                if (attrs[i]) {
+                  name = attrs[i].name;
+
+                  if (name.indexOf("data-") === 0) {
+                    name = camelCase(name.slice(5));
+                    dataAttr(elem, name, data[name]);
+                  }
+                }
+              }
+
+              dataPriv.set(elem, "hasDataAttrs", true);
+            }
+          }
+
+          return data;
+        } // Sets multiple values
+
+
+        if (typeof key === "object") {
+          return this.each(function () {
+            dataUser.set(this, key);
+          });
+        }
+
+        return access(this, function (value) {
+          var data; // The calling jQuery object (element matches) is not empty
+          // (and therefore has an element appears at this[ 0 ]) and the
+          // `value` parameter was not undefined. An empty jQuery object
+          // will result in `undefined` for elem = this[ 0 ] which will
+          // throw an exception if an attempt to read a data cache is made.
+
+          if (elem && value === undefined) {
+            // Attempt to get data from the cache
+            // The key will always be camelCased in Data
+            data = dataUser.get(elem, key);
+
+            if (data !== undefined) {
+              return data;
+            } // Attempt to "discover" the data in
+            // HTML5 custom data-* attrs
+
+
+            data = dataAttr(elem, key);
+
+            if (data !== undefined) {
+              return data;
+            } // We tried really hard, but the data doesn't exist.
+
+
+            return;
+          } // Set the data...
+
+
+          this.each(function () {
+            // We always store the camelCased key
+            dataUser.set(this, key, value);
+          });
+        }, null, value, arguments.length > 1, null, true);
+      },
+      removeData: function (key) {
+        return this.each(function () {
+          dataUser.remove(this, key);
+        });
+      }
+    });
+    jQuery.extend({
+      queue: function (elem, type, data) {
+        var queue;
+
+        if (elem) {
+          type = (type || "fx") + "queue";
+          queue = dataPriv.get(elem, type); // Speed up dequeue by getting out quickly if this is just a lookup
+
+          if (data) {
+            if (!queue || Array.isArray(data)) {
+              queue = dataPriv.access(elem, type, jQuery.makeArray(data));
+            } else {
+              queue.push(data);
+            }
+          }
+
+          return queue || [];
+        }
+      },
+      dequeue: function (elem, type) {
+        type = type || "fx";
+
+        var queue = jQuery.queue(elem, type),
+            startLength = queue.length,
+            fn = queue.shift(),
+            hooks = jQuery._queueHooks(elem, type),
+            next = function () {
+          jQuery.dequeue(elem, type);
+        }; // If the fx queue is dequeued, always remove the progress sentinel
+
+
+        if (fn === "inprogress") {
+          fn = queue.shift();
+          startLength--;
+        }
+
+        if (fn) {
+          // Add a progress sentinel to prevent the fx queue from being
+          // automatically dequeued
+          if (type === "fx") {
+            queue.unshift("inprogress");
+          } // Clear up the last queue stop function
+
+
+          delete hooks.stop;
+          fn.call(elem, next, hooks);
+        }
+
+        if (!startLength && hooks) {
+          hooks.empty.fire();
+        }
+      },
+      // Not public - generate a queueHooks object, or return the current one
+      _queueHooks: function (elem, type) {
+        var key = type + "queueHooks";
+        return dataPriv.get(elem, key) || dataPriv.access(elem, key, {
+          empty: jQuery.Callbacks("once memory").add(function () {
+            dataPriv.remove(elem, [type + "queue", key]);
+          })
+        });
+      }
+    });
+    jQuery.fn.extend({
+      queue: function (type, data) {
+        var setter = 2;
+
+        if (typeof type !== "string") {
+          data = type;
+          type = "fx";
+          setter--;
+        }
+
+        if (arguments.length < setter) {
+          return jQuery.queue(this[0], type);
+        }
+
+        return data === undefined ? this : this.each(function () {
+          var queue = jQuery.queue(this, type, data); // Ensure a hooks for this queue
+
+          jQuery._queueHooks(this, type);
+
+          if (type === "fx" && queue[0] !== "inprogress") {
+            jQuery.dequeue(this, type);
+          }
+        });
+      },
+      dequeue: function (type) {
+        return this.each(function () {
+          jQuery.dequeue(this, type);
+        });
+      },
+      clearQueue: function (type) {
+        return this.queue(type || "fx", []);
+      },
+      // Get a promise resolved when queues of a certain type
+      // are emptied (fx is the type by default)
+      promise: function (type, obj) {
+        var tmp,
+            count = 1,
+            defer = jQuery.Deferred(),
+            elements = this,
+            i = this.length,
+            resolve = function () {
+          if (! --count) {
+            defer.resolveWith(elements, [elements]);
+          }
+        };
+
+        if (typeof type !== "string") {
+          obj = type;
+          type = undefined;
+        }
+
+        type = type || "fx";
+
+        while (i--) {
+          tmp = dataPriv.get(elements[i], type + "queueHooks");
+
+          if (tmp && tmp.empty) {
+            count++;
+            tmp.empty.add(resolve);
+          }
+        }
+
+        resolve();
+        return defer.promise(obj);
+      }
+    });
+    var pnum = /[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/.source;
+    var rcssNum = new RegExp("^(?:([+-])=|)(" + pnum + ")([a-z%]*)$", "i");
+    var cssExpand = ["Top", "Right", "Bottom", "Left"];
+
+    var isHiddenWithinTree = function (elem, el) {
+      // isHiddenWithinTree might be called from jQuery#filter function;
+      // in that case, element will be second argument
+      elem = el || elem; // Inline style trumps all
+
+      return elem.style.display === "none" || elem.style.display === "" && // Otherwise, check computed style
+      // Support: Firefox <=43 - 45
+      // Disconnected elements can have computed display: none, so first confirm that elem is
+      // in the document.
+      jQuery.contains(elem.ownerDocument, elem) && jQuery.css(elem, "display") === "none";
+    };
+
+    var swap = function (elem, options, callback, args) {
+      var ret,
+          name,
+          old = {}; // Remember the old values, and insert the new ones
+
+      for (name in options) {
+        old[name] = elem.style[name];
+        elem.style[name] = options[name];
+      }
+
+      ret = callback.apply(elem, args || []); // Revert the old values
+
+      for (name in options) {
+        elem.style[name] = old[name];
+      }
+
+      return ret;
+    };
+
+    function adjustCSS(elem, prop, valueParts, tween) {
+      var adjusted,
+          scale,
+          maxIterations = 20,
+          currentValue = tween ? function () {
+        return tween.cur();
+      } : function () {
+        return jQuery.css(elem, prop, "");
+      },
+          initial = currentValue(),
+          unit = valueParts && valueParts[3] || (jQuery.cssNumber[prop] ? "" : "px"),
+          // Starting value computation is required for potential unit mismatches
+      initialInUnit = (jQuery.cssNumber[prop] || unit !== "px" && +initial) && rcssNum.exec(jQuery.css(elem, prop));
+
+      if (initialInUnit && initialInUnit[3] !== unit) {
+        // Support: Firefox <=54
+        // Halve the iteration target value to prevent interference from CSS upper bounds (gh-2144)
+        initial = initial / 2; // Trust units reported by jQuery.css
+
+        unit = unit || initialInUnit[3]; // Iteratively approximate from a nonzero starting point
+
+        initialInUnit = +initial || 1;
+
+        while (maxIterations--) {
+          // Evaluate and update our best guess (doubling guesses that zero out).
+          // Finish if the scale equals or crosses 1 (making the old*new product non-positive).
+          jQuery.style(elem, prop, initialInUnit + unit);
+
+          if ((1 - scale) * (1 - (scale = currentValue() / initial || 0.5)) <= 0) {
+            maxIterations = 0;
+          }
+
+          initialInUnit = initialInUnit / scale;
+        }
+
+        initialInUnit = initialInUnit * 2;
+        jQuery.style(elem, prop, initialInUnit + unit); // Make sure we update the tween properties later on
+
+        valueParts = valueParts || [];
+      }
+
+      if (valueParts) {
+        initialInUnit = +initialInUnit || +initial || 0; // Apply relative offset (+=/-=) if specified
+
+        adjusted = valueParts[1] ? initialInUnit + (valueParts[1] + 1) * valueParts[2] : +valueParts[2];
+
+        if (tween) {
+          tween.unit = unit;
+          tween.start = initialInUnit;
+          tween.end = adjusted;
+        }
+      }
+
+      return adjusted;
+    }
+
+    var defaultDisplayMap = {};
+
+    function getDefaultDisplay(elem) {
+      var temp,
+          doc = elem.ownerDocument,
+          nodeName = elem.nodeName,
+          display = defaultDisplayMap[nodeName];
+
+      if (display) {
+        return display;
+      }
+
+      temp = doc.body.appendChild(doc.createElement(nodeName));
+      display = jQuery.css(temp, "display");
+      temp.parentNode.removeChild(temp);
+
+      if (display === "none") {
+        display = "block";
+      }
+
+      defaultDisplayMap[nodeName] = display;
+      return display;
+    }
+
+    function showHide(elements, show) {
+      var display,
+          elem,
+          values = [],
+          index = 0,
+          length = elements.length; // Determine new display value for elements that need to change
+
+      for (; index < length; index++) {
+        elem = elements[index];
+
+        if (!elem.style) {
+          continue;
+        }
+
+        display = elem.style.display;
+
+        if (show) {
+          // Since we force visibility upon cascade-hidden elements, an immediate (and slow)
+          // check is required in this first loop unless we have a nonempty display value (either
+          // inline or about-to-be-restored)
+          if (display === "none") {
+            values[index] = dataPriv.get(elem, "display") || null;
+
+            if (!values[index]) {
+              elem.style.display = "";
+            }
+          }
+
+          if (elem.style.display === "" && isHiddenWithinTree(elem)) {
+            values[index] = getDefaultDisplay(elem);
+          }
+        } else {
+          if (display !== "none") {
+            values[index] = "none"; // Remember what we're overwriting
+
+            dataPriv.set(elem, "display", display);
+          }
+        }
+      } // Set the display of the elements in a second loop to avoid constant reflow
+
+
+      for (index = 0; index < length; index++) {
+        if (values[index] != null) {
+          elements[index].style.display = values[index];
+        }
+      }
+
+      return elements;
+    }
+
+    jQuery.fn.extend({
+      show: function () {
+        return showHide(this, true);
+      },
+      hide: function () {
+        return showHide(this);
+      },
+      toggle: function (state) {
+        if (typeof state === "boolean") {
+          return state ? this.show() : this.hide();
+        }
+
+        return this.each(function () {
+          if (isHiddenWithinTree(this)) {
+            jQuery(this).show();
+          } else {
+            jQuery(this).hide();
+          }
+        });
+      }
+    });
+    var rcheckableType = /^(?:checkbox|radio)$/i;
+    var rtagName = /<([a-z][^\/\0>\x20\t\r\n\f]+)/i;
+    var rscriptType = /^$|^module$|\/(?:java|ecma)script/i; // We have to close these tags to support XHTML (#13200)
+
+    var wrapMap = {
+      // Support: IE <=9 only
+      option: [1, "<select multiple='multiple'>", "</select>"],
+      // XHTML parsers do not magically insert elements in the
+      // same way that tag soup parsers do. So we cannot shorten
+      // this by omitting <tbody> or other required elements.
+      thead: [1, "<table>", "</table>"],
+      col: [2, "<table><colgroup>", "</colgroup></table>"],
+      tr: [2, "<table><tbody>", "</tbody></table>"],
+      td: [3, "<table><tbody><tr>", "</tr></tbody></table>"],
+      _default: [0, "", ""]
+    }; // Support: IE <=9 only
+
+    wrapMap.optgroup = wrapMap.option;
+    wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead;
+    wrapMap.th = wrapMap.td;
+
+    function getAll(context, tag) {
+      // Support: IE <=9 - 11 only
+      // Use typeof to avoid zero-argument method invocation on host objects (#15151)
+      var ret;
+
+      if (typeof context.getElementsByTagName !== "undefined") {
+        ret = context.getElementsByTagName(tag || "*");
+      } else if (typeof context.querySelectorAll !== "undefined") {
+        ret = context.querySelectorAll(tag || "*");
+      } else {
+        ret = [];
+      }
+
+      if (tag === undefined || tag && nodeName(context, tag)) {
+        return jQuery.merge([context], ret);
+      }
+
+      return ret;
+    } // Mark scripts as having already been evaluated
+
+
+    function setGlobalEval(elems, refElements) {
+      var i = 0,
+          l = elems.length;
+
+      for (; i < l; i++) {
+        dataPriv.set(elems[i], "globalEval", !refElements || dataPriv.get(refElements[i], "globalEval"));
+      }
+    }
+
+    var rhtml = /<|&#?\w+;/;
+
+    function buildFragment(elems, context, scripts, selection, ignored) {
+      var elem,
+          tmp,
+          tag,
+          wrap,
+          contains,
+          j,
+          fragment = context.createDocumentFragment(),
+          nodes = [],
+          i = 0,
+          l = elems.length;
+
+      for (; i < l; i++) {
+        elem = elems[i];
+
+        if (elem || elem === 0) {
+          // Add nodes directly
+          if (toType(elem) === "object") {
+            // Support: Android <=4.0 only, PhantomJS 1 only
+            // push.apply(_, arraylike) throws on ancient WebKit
+            jQuery.merge(nodes, elem.nodeType ? [elem] : elem); // Convert non-html into a text node
+          } else if (!rhtml.test(elem)) {
+            nodes.push(context.createTextNode(elem)); // Convert html into DOM nodes
+          } else {
+            tmp = tmp || fragment.appendChild(context.createElement("div")); // Deserialize a standard representation
+
+            tag = (rtagName.exec(elem) || ["", ""])[1].toLowerCase();
+            wrap = wrapMap[tag] || wrapMap._default;
+            tmp.innerHTML = wrap[1] + jQuery.htmlPrefilter(elem) + wrap[2]; // Descend through wrappers to the right content
+
+            j = wrap[0];
+
+            while (j--) {
+              tmp = tmp.lastChild;
+            } // Support: Android <=4.0 only, PhantomJS 1 only
+            // push.apply(_, arraylike) throws on ancient WebKit
+
+
+            jQuery.merge(nodes, tmp.childNodes); // Remember the top-level container
+
+            tmp = fragment.firstChild; // Ensure the created nodes are orphaned (#12392)
+
+            tmp.textContent = "";
+          }
+        }
+      } // Remove wrapper from fragment
+
+
+      fragment.textContent = "";
+      i = 0;
+
+      while (elem = nodes[i++]) {
+        // Skip elements already in the context collection (trac-4087)
+        if (selection && jQuery.inArray(elem, selection) > -1) {
+          if (ignored) {
+            ignored.push(elem);
+          }
+
+          continue;
+        }
+
+        contains = jQuery.contains(elem.ownerDocument, elem); // Append to fragment
+
+        tmp = getAll(fragment.appendChild(elem), "script"); // Preserve script evaluation history
+
+        if (contains) {
+          setGlobalEval(tmp);
+        } // Capture executables
+
+
+        if (scripts) {
+          j = 0;
+
+          while (elem = tmp[j++]) {
+            if (rscriptType.test(elem.type || "")) {
+              scripts.push(elem);
+            }
+          }
+        }
+      }
+
+      return fragment;
+    }
+
+    (function () {
+      var fragment = document$2.createDocumentFragment(),
+          div = fragment.appendChild(document$2.createElement("div")),
+          input = document$2.createElement("input"); // Support: Android 4.0 - 4.3 only
+      // Check state lost if the name is set (#11217)
+      // Support: Windows Web Apps (WWA)
+      // `name` and `type` must use .setAttribute for WWA (#14901)
+
+      input.setAttribute("type", "radio");
+      input.setAttribute("checked", "checked");
+      input.setAttribute("name", "t");
+      div.appendChild(input); // Support: Android <=4.1 only
+      // Older WebKit doesn't clone checked state correctly in fragments
+
+      support.checkClone = div.cloneNode(true).cloneNode(true).lastChild.checked; // Support: IE <=11 only
+      // Make sure textarea (and checkbox) defaultValue is properly cloned
+
+      div.innerHTML = "<textarea>x</textarea>";
+      support.noCloneChecked = !!div.cloneNode(true).lastChild.defaultValue;
+    })();
+
+    var documentElement = document$2.documentElement;
+    var rkeyEvent = /^key/,
+        rmouseEvent = /^(?:mouse|pointer|contextmenu|drag|drop)|click/,
+        rtypenamespace = /^([^.]*)(?:\.(.+)|)/;
+
+    function returnTrue() {
+      return true;
+    }
+
+    function returnFalse() {
+      return false;
+    } // Support: IE <=9 only
+    // See #13393 for more info
+
+
+    function safeActiveElement() {
+      try {
+        return document$2.activeElement;
+      } catch (err) {}
+    }
+
+    function on(elem, types, selector, data, fn, one) {
+      var origFn, type; // Types can be a map of types/handlers
+
+      if (typeof types === "object") {
+        // ( types-Object, selector, data )
+        if (typeof selector !== "string") {
+          // ( types-Object, data )
+          data = data || selector;
+          selector = undefined;
+        }
+
+        for (type in types) {
+          on(elem, type, selector, data, types[type], one);
+        }
+
+        return elem;
+      }
+
+      if (data == null && fn == null) {
+        // ( types, fn )
+        fn = selector;
+        data = selector = undefined;
+      } else if (fn == null) {
+        if (typeof selector === "string") {
+          // ( types, selector, fn )
+          fn = data;
+          data = undefined;
+        } else {
+          // ( types, data, fn )
+          fn = data;
+          data = selector;
+          selector = undefined;
+        }
+      }
+
+      if (fn === false) {
+        fn = returnFalse;
+      } else if (!fn) {
+        return elem;
+      }
+
+      if (one === 1) {
+        origFn = fn;
+
+        fn = function (event) {
+          // Can use an empty set, since event contains the info
+          jQuery().off(event);
+          return origFn.apply(this, arguments);
+        }; // Use same guid so caller can remove using origFn
+
+
+        fn.guid = origFn.guid || (origFn.guid = jQuery.guid++);
+      }
+
+      return elem.each(function () {
+        jQuery.event.add(this, types, fn, data, selector);
+      });
+    }
+    /*
+     * Helper functions for managing events -- not part of the public interface.
+     * Props to Dean Edwards' addEvent library for many of the ideas.
+     */
+
+
+    jQuery.event = {
+      global: {},
+      add: function (elem, types, handler, data, selector) {
+        var handleObjIn,
+            eventHandle,
+            tmp,
+            events,
+            t,
+            handleObj,
+            special,
+            handlers,
+            type,
+            namespaces,
+            origType,
+            elemData = dataPriv.get(elem); // Don't attach events to noData or text/comment nodes (but allow plain objects)
+
+        if (!elemData) {
+          return;
+        } // Caller can pass in an object of custom data in lieu of the handler
+
+
+        if (handler.handler) {
+          handleObjIn = handler;
+          handler = handleObjIn.handler;
+          selector = handleObjIn.selector;
+        } // Ensure that invalid selectors throw exceptions at attach time
+        // Evaluate against documentElement in case elem is a non-element node (e.g., document)
+
+
+        if (selector) {
+          jQuery.find.matchesSelector(documentElement, selector);
+        } // Make sure that the handler has a unique ID, used to find/remove it later
+
+
+        if (!handler.guid) {
+          handler.guid = jQuery.guid++;
+        } // Init the element's event structure and main handler, if this is the first
+
+
+        if (!(events = elemData.events)) {
+          events = elemData.events = {};
+        }
+
+        if (!(eventHandle = elemData.handle)) {
+          eventHandle = elemData.handle = function (e) {
+            // Discard the second event of a jQuery.event.trigger() and
+            // when an event is called after a page has unloaded
+            return typeof jQuery !== "undefined" && jQuery.event.triggered !== e.type ? jQuery.event.dispatch.apply(elem, arguments) : undefined;
+          };
+        } // Handle multiple events separated by a space
+
+
+        types = (types || "").match(rnothtmlwhite) || [""];
+        t = types.length;
+
+        while (t--) {
+          tmp = rtypenamespace.exec(types[t]) || [];
+          type = origType = tmp[1];
+          namespaces = (tmp[2] || "").split(".").sort(); // There *must* be a type, no attaching namespace-only handlers
+
+          if (!type) {
+            continue;
+          } // If event changes its type, use the special event handlers for the changed type
+
+
+          special = jQuery.event.special[type] || {}; // If selector defined, determine special event api type, otherwise given type
+
+          type = (selector ? special.delegateType : special.bindType) || type; // Update special based on newly reset type
+
+          special = jQuery.event.special[type] || {}; // handleObj is passed to all event handlers
+
+          handleObj = jQuery.extend({
+            type: type,
+            origType: origType,
+            data: data,
+            handler: handler,
+            guid: handler.guid,
+            selector: selector,
+            needsContext: selector && jQuery.expr.match.needsContext.test(selector),
+            namespace: namespaces.join(".")
+          }, handleObjIn); // Init the event handler queue if we're the first
+
+          if (!(handlers = events[type])) {
+            handlers = events[type] = [];
+            handlers.delegateCount = 0; // Only use addEventListener if the special events handler returns false
+
+            if (!special.setup || special.setup.call(elem, data, namespaces, eventHandle) === false) {
+              if (elem.addEventListener) {
+                elem.addEventListener(type, eventHandle);
+              }
+            }
+          }
+
+          if (special.add) {
+            special.add.call(elem, handleObj);
+
+            if (!handleObj.handler.guid) {
+              handleObj.handler.guid = handler.guid;
+            }
+          } // Add to the element's handler list, delegates in front
+
+
+          if (selector) {
+            handlers.splice(handlers.delegateCount++, 0, handleObj);
+          } else {
+            handlers.push(handleObj);
+          } // Keep track of which events have ever been used, for event optimization
+
+
+          jQuery.event.global[type] = true;
+        }
+      },
+      // Detach an event or set of events from an element
+      remove: function (elem, types, handler, selector, mappedTypes) {
+        var j,
+            origCount,
+            tmp,
+            events,
+            t,
+            handleObj,
+            special,
+            handlers,
+            type,
+            namespaces,
+            origType,
+            elemData = dataPriv.hasData(elem) && dataPriv.get(elem);
+
+        if (!elemData || !(events = elemData.events)) {
+          return;
+        } // Once for each type.namespace in types; type may be omitted
+
+
+        types = (types || "").match(rnothtmlwhite) || [""];
+        t = types.length;
+
+        while (t--) {
+          tmp = rtypenamespace.exec(types[t]) || [];
+          type = origType = tmp[1];
+          namespaces = (tmp[2] || "").split(".").sort(); // Unbind all events (on this namespace, if provided) for the element
+
+          if (!type) {
+            for (type in events) {
+              jQuery.event.remove(elem, type + types[t], handler, selector, true);
+            }
+
+            continue;
+          }
+
+          special = jQuery.event.special[type] || {};
+          type = (selector ? special.delegateType : special.bindType) || type;
+          handlers = events[type] || [];
+          tmp = tmp[2] && new RegExp("(^|\\.)" + namespaces.join("\\.(?:.*\\.|)") + "(\\.|$)"); // Remove matching events
+
+          origCount = j = handlers.length;
+
+          while (j--) {
+            handleObj = handlers[j];
+
+            if ((mappedTypes || origType === handleObj.origType) && (!handler || handler.guid === handleObj.guid) && (!tmp || tmp.test(handleObj.namespace)) && (!selector || selector === handleObj.selector || selector === "**" && handleObj.selector)) {
+              handlers.splice(j, 1);
+
+              if (handleObj.selector) {
+                handlers.delegateCount--;
+              }
+
+              if (special.remove) {
+                special.remove.call(elem, handleObj);
+              }
+            }
+          } // Remove generic event handler if we removed something and no more handlers exist
+          // (avoids potential for endless recursion during removal of special event handlers)
+
+
+          if (origCount && !handlers.length) {
+            if (!special.teardown || special.teardown.call(elem, namespaces, elemData.handle) === false) {
+              jQuery.removeEvent(elem, type, elemData.handle);
+            }
+
+            delete events[type];
+          }
+        } // Remove data and the expando if it's no longer used
+
+
+        if (jQuery.isEmptyObject(events)) {
+          dataPriv.remove(elem, "handle events");
+        }
+      },
+      dispatch: function (nativeEvent) {
+        // Make a writable jQuery.Event from the native event object
+        var event = jQuery.event.fix(nativeEvent);
+        var i,
+            j,
+            ret,
+            matched,
+            handleObj,
+            handlerQueue,
+            args = new Array(arguments.length),
+            handlers = (dataPriv.get(this, "events") || {})[event.type] || [],
+            special = jQuery.event.special[event.type] || {}; // Use the fix-ed jQuery.Event rather than the (read-only) native event
+
+        args[0] = event;
+
+        for (i = 1; i < arguments.length; i++) {
+          args[i] = arguments[i];
+        }
+
+        event.delegateTarget = this; // Call the preDispatch hook for the mapped type, and let it bail if desired
+
+        if (special.preDispatch && special.preDispatch.call(this, event) === false) {
+          return;
+        } // Determine handlers
+
+
+        handlerQueue = jQuery.event.handlers.call(this, event, handlers); // Run delegates first; they may want to stop propagation beneath us
+
+        i = 0;
+
+        while ((matched = handlerQueue[i++]) && !event.isPropagationStopped()) {
+          event.currentTarget = matched.elem;
+          j = 0;
+
+          while ((handleObj = matched.handlers[j++]) && !event.isImmediatePropagationStopped()) {
+            // Triggered event must either 1) have no namespace, or 2) have namespace(s)
+            // a subset or equal to those in the bound event (both can have no namespace).
+            if (!event.rnamespace || event.rnamespace.test(handleObj.namespace)) {
+              event.handleObj = handleObj;
+              event.data = handleObj.data;
+              ret = ((jQuery.event.special[handleObj.origType] || {}).handle || handleObj.handler).apply(matched.elem, args);
+
+              if (ret !== undefined) {
+                if ((event.result = ret) === false) {
+                  event.preventDefault();
+                  event.stopPropagation();
+                }
+              }
+            }
+          }
+        } // Call the postDispatch hook for the mapped type
+
+
+        if (special.postDispatch) {
+          special.postDispatch.call(this, event);
+        }
+
+        return event.result;
+      },
+      handlers: function (event, handlers) {
+        var i,
+            handleObj,
+            sel,
+            matchedHandlers,
+            matchedSelectors,
+            handlerQueue = [],
+            delegateCount = handlers.delegateCount,
+            cur = event.target; // Find delegate handlers
+
+        if (delegateCount && // Support: IE <=9
+        // Black-hole SVG <use> instance trees (trac-13180)
+        cur.nodeType && // Support: Firefox <=42
+        // Suppress spec-violating clicks indicating a non-primary pointer button (trac-3861)
+        // https://www.w3.org/TR/DOM-Level-3-Events/#event-type-click
+        // Support: IE 11 only
+        // ...but not arrow key "clicks" of radio inputs, which can have `button` -1 (gh-2343)
+        !(event.type === "click" && event.button >= 1)) {
+          for (; cur !== this; cur = cur.parentNode || this) {
+            // Don't check non-elements (#13208)
+            // Don't process clicks on disabled elements (#6911, #8165, #11382, #11764)
+            if (cur.nodeType === 1 && !(event.type === "click" && cur.disabled === true)) {
+              matchedHandlers = [];
+              matchedSelectors = {};
+
+              for (i = 0; i < delegateCount; i++) {
+                handleObj = handlers[i]; // Don't conflict with Object.prototype properties (#13203)
+
+                sel = handleObj.selector + " ";
+
+                if (matchedSelectors[sel] === undefined) {
+                  matchedSelectors[sel] = handleObj.needsContext ? jQuery(sel, this).index(cur) > -1 : jQuery.find(sel, this, null, [cur]).length;
+                }
+
+                if (matchedSelectors[sel]) {
+                  matchedHandlers.push(handleObj);
+                }
+              }
+
+              if (matchedHandlers.length) {
+                handlerQueue.push({
+                  elem: cur,
+                  handlers: matchedHandlers
+                });
+              }
+            }
+          }
+        } // Add the remaining (directly-bound) handlers
+
+
+        cur = this;
+
+        if (delegateCount < handlers.length) {
+          handlerQueue.push({
+            elem: cur,
+            handlers: handlers.slice(delegateCount)
+          });
+        }
+
+        return handlerQueue;
+      },
+      addProp: function (name, hook) {
+        Object.defineProperty(jQuery.Event.prototype, name, {
+          enumerable: true,
+          configurable: true,
+          get: isFunction(hook) ? function () {
+            if (this.originalEvent) {
+              return hook(this.originalEvent);
+            }
+          } : function () {
+            if (this.originalEvent) {
+              return this.originalEvent[name];
+            }
+          },
+          set: function (value) {
+            Object.defineProperty(this, name, {
+              enumerable: true,
+              configurable: true,
+              writable: true,
+              value: value
+            });
+          }
+        });
+      },
+      fix: function (originalEvent) {
+        return originalEvent[jQuery.expando] ? originalEvent : new jQuery.Event(originalEvent);
+      },
+      special: {
+        load: {
+          // Prevent triggered image.load events from bubbling to window.load
+          noBubble: true
+        },
+        focus: {
+          // Fire native event if possible so blur/focus sequence is correct
+          trigger: function () {
+            if (this !== safeActiveElement() && this.focus) {
+              this.focus();
+              return false;
+            }
+          },
+          delegateType: "focusin"
+        },
+        blur: {
+          trigger: function () {
+            if (this === safeActiveElement() && this.blur) {
+              this.blur();
+              return false;
+            }
+          },
+          delegateType: "focusout"
+        },
+        click: {
+          // For checkbox, fire native event so checked state will be right
+          trigger: function () {
+            if (this.type === "checkbox" && this.click && nodeName(this, "input")) {
+              this.click();
+              return false;
+            }
+          },
+          // For cross-browser consistency, don't fire native .click() on links
+          _default: function (event) {
+            return nodeName(event.target, "a");
+          }
+        },
+        beforeunload: {
+          postDispatch: function (event) {
+            // Support: Firefox 20+
+            // Firefox doesn't alert if the returnValue field is not set.
+            if (event.result !== undefined && event.originalEvent) {
+              event.originalEvent.returnValue = event.result;
+            }
+          }
+        }
+      }
+    };
+
+    jQuery.removeEvent = function (elem, type, handle) {
+      // This "if" is needed for plain objects
+      if (elem.removeEventListener) {
+        elem.removeEventListener(type, handle);
+      }
+    };
+
+    jQuery.Event = function (src, props) {
+      // Allow instantiation without the 'new' keyword
+      if (!(this instanceof jQuery.Event)) {
+        return new jQuery.Event(src, props);
+      } // Event object
+
+
+      if (src && src.type) {
+        this.originalEvent = src;
+        this.type = src.type; // Events bubbling up the document may have been marked as prevented
+        // by a handler lower down the tree; reflect the correct value.
+
+        this.isDefaultPrevented = src.defaultPrevented || src.defaultPrevented === undefined && // Support: Android <=2.3 only
+        src.returnValue === false ? returnTrue : returnFalse; // Create target properties
+        // Support: Safari <=6 - 7 only
+        // Target should not be a text node (#504, #13143)
+
+        this.target = src.target && src.target.nodeType === 3 ? src.target.parentNode : src.target;
+        this.currentTarget = src.currentTarget;
+        this.relatedTarget = src.relatedTarget; // Event type
+      } else {
+        this.type = src;
+      } // Put explicitly provided properties onto the event object
+
+
+      if (props) {
+        jQuery.extend(this, props);
+      } // Create a timestamp if incoming event doesn't have one
+
+
+      this.timeStamp = src && src.timeStamp || Date.now(); // Mark it as fixed
+
+      this[jQuery.expando] = true;
+    }; // jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding
+    // https://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html
+
+
+    jQuery.Event.prototype = {
+      constructor: jQuery.Event,
+      isDefaultPrevented: returnFalse,
+      isPropagationStopped: returnFalse,
+      isImmediatePropagationStopped: returnFalse,
+      isSimulated: false,
+      preventDefault: function () {
+        var e = this.originalEvent;
+        this.isDefaultPrevented = returnTrue;
+
+        if (e && !this.isSimulated) {
+          e.preventDefault();
+        }
+      },
+      stopPropagation: function () {
+        var e = this.originalEvent;
+        this.isPropagationStopped = returnTrue;
+
+        if (e && !this.isSimulated) {
+          e.stopPropagation();
+        }
+      },
+      stopImmediatePropagation: function () {
+        var e = this.originalEvent;
+        this.isImmediatePropagationStopped = returnTrue;
+
+        if (e && !this.isSimulated) {
+          e.stopImmediatePropagation();
+        }
+
+        this.stopPropagation();
+      }
+    }; // Includes all common event props including KeyEvent and MouseEvent specific props
+
+    jQuery.each({
+      altKey: true,
+      bubbles: true,
+      cancelable: true,
+      changedTouches: true,
+      ctrlKey: true,
+      detail: true,
+      eventPhase: true,
+      metaKey: true,
+      pageX: true,
+      pageY: true,
+      shiftKey: true,
+      view: true,
+      "char": true,
+      charCode: true,
+      key: true,
+      keyCode: true,
+      button: true,
+      buttons: true,
+      clientX: true,
+      clientY: true,
+      offsetX: true,
+      offsetY: true,
+      pointerId: true,
+      pointerType: true,
+      screenX: true,
+      screenY: true,
+      targetTouches: true,
+      toElement: true,
+      touches: true,
+      which: function (event) {
+        var button = event.button; // Add which for key events
+
+        if (event.which == null && rkeyEvent.test(event.type)) {
+          return event.charCode != null ? event.charCode : event.keyCode;
+        } // Add which for click: 1 === left; 2 === middle; 3 === right
+
+
+        if (!event.which && button !== undefined && rmouseEvent.test(event.type)) {
+          if (button & 1) {
+            return 1;
+          }
+
+          if (button & 2) {
+            return 3;
+          }
+
+          if (button & 4) {
+            return 2;
+          }
+
+          return 0;
+        }
+
+        return event.which;
+      }
+    }, jQuery.event.addProp); // Create mouseenter/leave events using mouseover/out and event-time checks
+    // so that event delegation works in jQuery.
+    // Do the same for pointerenter/pointerleave and pointerover/pointerout
+    //
+    // Support: Safari 7 only
+    // Safari sends mouseenter too often; see:
+    // https://bugs.chromium.org/p/chromium/issues/detail?id=470258
+    // for the description of the bug (it existed in older Chrome versions as well).
+
+    jQuery.each({
+      mouseenter: "mouseover",
+      mouseleave: "mouseout",
+      pointerenter: "pointerover",
+      pointerleave: "pointerout"
+    }, function (orig, fix) {
+      jQuery.event.special[orig] = {
+        delegateType: fix,
+        bindType: fix,
+        handle: function (event) {
+          var ret,
+              target = this,
+              related = event.relatedTarget,
+              handleObj = event.handleObj; // For mouseenter/leave call the handler if related is outside the target.
+          // NB: No relatedTarget if the mouse left/entered the browser window
+
+          if (!related || related !== target && !jQuery.contains(target, related)) {
+            event.type = handleObj.origType;
+            ret = handleObj.handler.apply(this, arguments);
+            event.type = fix;
+          }
+
+          return ret;
+        }
+      };
+    });
+    jQuery.fn.extend({
+      on: function (types, selector, data, fn) {
+        return on(this, types, selector, data, fn);
+      },
+      one: function (types, selector, data, fn) {
+        return on(this, types, selector, data, fn, 1);
+      },
+      off: function (types, selector, fn) {
+        var handleObj, type;
+
+        if (types && types.preventDefault && types.handleObj) {
+          // ( event )  dispatched jQuery.Event
+          handleObj = types.handleObj;
+          jQuery(types.delegateTarget).off(handleObj.namespace ? handleObj.origType + "." + handleObj.namespace : handleObj.origType, handleObj.selector, handleObj.handler);
+          return this;
+        }
+
+        if (typeof types === "object") {
+          // ( types-object [, selector] )
+          for (type in types) {
+            this.off(type, selector, types[type]);
+          }
+
+          return this;
+        }
+
+        if (selector === false || typeof selector === "function") {
+          // ( types [, fn] )
+          fn = selector;
+          selector = undefined;
+        }
+
+        if (fn === false) {
+          fn = returnFalse;
+        }
+
+        return this.each(function () {
+          jQuery.event.remove(this, types, fn, selector);
+        });
+      }
+    });
+    var
+    /* eslint-disable max-len */
+    // See https://github.com/eslint/eslint/issues/3229
+    rxhtmlTag = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([a-z][^\/\0>\x20\t\r\n\f]*)[^>]*)\/>/gi,
+
+    /* eslint-enable */
+    // Support: IE <=10 - 11, Edge 12 - 13 only
+    // In IE/Edge using regex groups here causes severe slowdowns.
+    // See https://connect.microsoft.com/IE/feedback/details/1736512/
+    rnoInnerhtml = /<script|<style|<link/i,
+        // checked="checked" or checked
+    rchecked = /checked\s*(?:[^=]|=\s*.checked.)/i,
+        rcleanScript = /^\s*<!(?:\[CDATA\[|--)|(?:\]\]|--)>\s*$/g; // Prefer a tbody over its parent table for containing new rows
+
+    function manipulationTarget(elem, content) {
+      if (nodeName(elem, "table") && nodeName(content.nodeType !== 11 ? content : content.firstChild, "tr")) {
+        return jQuery(elem).children("tbody")[0] || elem;
+      }
+
+      return elem;
+    } // Replace/restore the type attribute of script elements for safe DOM manipulation
+
+
+    function disableScript(elem) {
+      elem.type = (elem.getAttribute("type") !== null) + "/" + elem.type;
+      return elem;
+    }
+
+    function restoreScript(elem) {
+      if ((elem.type || "").slice(0, 5) === "true/") {
+        elem.type = elem.type.slice(5);
+      } else {
+        elem.removeAttribute("type");
+      }
+
+      return elem;
+    }
+
+    function cloneCopyEvent(src, dest) {
+      var i, l, type, pdataOld, pdataCur, udataOld, udataCur, events;
+
+      if (dest.nodeType !== 1) {
+        return;
+      } // 1. Copy private data: events, handlers, etc.
+
+
+      if (dataPriv.hasData(src)) {
+        pdataOld = dataPriv.access(src);
+        pdataCur = dataPriv.set(dest, pdataOld);
+        events = pdataOld.events;
+
+        if (events) {
+          delete pdataCur.handle;
+          pdataCur.events = {};
+
+          for (type in events) {
+            for (i = 0, l = events[type].length; i < l; i++) {
+              jQuery.event.add(dest, type, events[type][i]);
+            }
+          }
+        }
+      } // 2. Copy user data
+
+
+      if (dataUser.hasData(src)) {
+        udataOld = dataUser.access(src);
+        udataCur = jQuery.extend({}, udataOld);
+        dataUser.set(dest, udataCur);
+      }
+    } // Fix IE bugs, see support tests
+
+
+    function fixInput(src, dest) {
+      var nodeName = dest.nodeName.toLowerCase(); // Fails to persist the checked state of a cloned checkbox or radio button.
+
+      if (nodeName === "input" && rcheckableType.test(src.type)) {
+        dest.checked = src.checked; // Fails to return the selected option to the default selected state when cloning options
+      } else if (nodeName === "input" || nodeName === "textarea") {
+        dest.defaultValue = src.defaultValue;
+      }
+    }
+
+    function domManip(collection, args, callback, ignored) {
+      // Flatten any nested arrays
+      args = concat.apply([], args);
+      var fragment,
+          first,
+          scripts,
+          hasScripts,
+          node,
+          doc,
+          i = 0,
+          l = collection.length,
+          iNoClone = l - 1,
+          value = args[0],
+          valueIsFunction = isFunction(value); // We can't cloneNode fragments that contain checked, in WebKit
+
+      if (valueIsFunction || l > 1 && typeof value === "string" && !support.checkClone && rchecked.test(value)) {
+        return collection.each(function (index) {
+          var self = collection.eq(index);
+
+          if (valueIsFunction) {
+            args[0] = value.call(this, index, self.html());
+          }
+
+          domManip(self, args, callback, ignored);
+        });
+      }
+
+      if (l) {
+        fragment = buildFragment(args, collection[0].ownerDocument, false, collection, ignored);
+        first = fragment.firstChild;
+
+        if (fragment.childNodes.length === 1) {
+          fragment = first;
+        } // Require either new content or an interest in ignored elements to invoke the callback
+
+
+        if (first || ignored) {
+          scripts = jQuery.map(getAll(fragment, "script"), disableScript);
+          hasScripts = scripts.length; // Use the original fragment for the last item
+          // instead of the first because it can end up
+          // being emptied incorrectly in certain situations (#8070).
+
+          for (; i < l; i++) {
+            node = fragment;
+
+            if (i !== iNoClone) {
+              node = jQuery.clone(node, true, true); // Keep references to cloned scripts for later restoration
+
+              if (hasScripts) {
+                // Support: Android <=4.0 only, PhantomJS 1 only
+                // push.apply(_, arraylike) throws on ancient WebKit
+                jQuery.merge(scripts, getAll(node, "script"));
+              }
+            }
+
+            callback.call(collection[i], node, i);
+          }
+
+          if (hasScripts) {
+            doc = scripts[scripts.length - 1].ownerDocument; // Reenable scripts
+
+            jQuery.map(scripts, restoreScript); // Evaluate executable scripts on first document insertion
+
+            for (i = 0; i < hasScripts; i++) {
+              node = scripts[i];
+
+              if (rscriptType.test(node.type || "") && !dataPriv.access(node, "globalEval") && jQuery.contains(doc, node)) {
+                if (node.src && (node.type || "").toLowerCase() !== "module") {
+                  // Optional AJAX dependency, but won't run scripts if not present
+                  if (jQuery._evalUrl) {
+                    jQuery._evalUrl(node.src);
+                  }
+                } else {
+                  DOMEval(node.textContent.replace(rcleanScript, ""), doc, node);
+                }
+              }
+            }
+          }
+        }
+      }
+
+      return collection;
+    }
+
+    function remove(elem, selector, keepData) {
+      var node,
+          nodes = selector ? jQuery.filter(selector, elem) : elem,
+          i = 0;
+
+      for (; (node = nodes[i]) != null; i++) {
+        if (!keepData && node.nodeType === 1) {
+          jQuery.cleanData(getAll(node));
+        }
+
+        if (node.parentNode) {
+          if (keepData && jQuery.contains(node.ownerDocument, node)) {
+            setGlobalEval(getAll(node, "script"));
+          }
+
+          node.parentNode.removeChild(node);
+        }
+      }
+
+      return elem;
+    }
+
+    jQuery.extend({
+      htmlPrefilter: function (html) {
+        return html.replace(rxhtmlTag, "<$1></$2>");
+      },
+      clone: function (elem, dataAndEvents, deepDataAndEvents) {
+        var i,
+            l,
+            srcElements,
+            destElements,
+            clone = elem.cloneNode(true),
+            inPage = jQuery.contains(elem.ownerDocument, elem); // Fix IE cloning issues
+
+        if (!support.noCloneChecked && (elem.nodeType === 1 || elem.nodeType === 11) && !jQuery.isXMLDoc(elem)) {
+          // We eschew Sizzle here for performance reasons: https://jsperf.com/getall-vs-sizzle/2
+          destElements = getAll(clone);
+          srcElements = getAll(elem);
+
+          for (i = 0, l = srcElements.length; i < l; i++) {
+            fixInput(srcElements[i], destElements[i]);
+          }
+        } // Copy the events from the original to the clone
+
+
+        if (dataAndEvents) {
+          if (deepDataAndEvents) {
+            srcElements = srcElements || getAll(elem);
+            destElements = destElements || getAll(clone);
+
+            for (i = 0, l = srcElements.length; i < l; i++) {
+              cloneCopyEvent(srcElements[i], destElements[i]);
+            }
+          } else {
+            cloneCopyEvent(elem, clone);
+          }
+        } // Preserve script evaluation history
+
+
+        destElements = getAll(clone, "script");
+
+        if (destElements.length > 0) {
+          setGlobalEval(destElements, !inPage && getAll(elem, "script"));
+        } // Return the cloned set
+
+
+        return clone;
+      },
+      cleanData: function (elems) {
+        var data,
+            elem,
+            type,
+            special = jQuery.event.special,
+            i = 0;
+
+        for (; (elem = elems[i]) !== undefined; i++) {
+          if (acceptData(elem)) {
+            if (data = elem[dataPriv.expando]) {
+              if (data.events) {
+                for (type in data.events) {
+                  if (special[type]) {
+                    jQuery.event.remove(elem, type); // This is a shortcut to avoid jQuery.event.remove's overhead
+                  } else {
+                    jQuery.removeEvent(elem, type, data.handle);
+                  }
+                }
+              } // Support: Chrome <=35 - 45+
+              // Assign undefined instead of using delete, see Data#remove
+
+
+              elem[dataPriv.expando] = undefined;
+            }
+
+            if (elem[dataUser.expando]) {
+              // Support: Chrome <=35 - 45+
+              // Assign undefined instead of using delete, see Data#remove
+              elem[dataUser.expando] = undefined;
+            }
+          }
+        }
+      }
+    });
+    jQuery.fn.extend({
+      detach: function (selector) {
+        return remove(this, selector, true);
+      },
+      remove: function (selector) {
+        return remove(this, selector);
+      },
+      text: function (value) {
+        return access(this, function (value) {
+          return value === undefined ? jQuery.text(this) : this.empty().each(function () {
+            if (this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9) {
+              this.textContent = value;
+            }
+          });
+        }, null, value, arguments.length);
+      },
+      append: function () {
+        return domManip(this, arguments, function (elem) {
+          if (this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9) {
+            var target = manipulationTarget(this, elem);
+            target.appendChild(elem);
+          }
+        });
+      },
+      prepend: function () {
+        return domManip(this, arguments, function (elem) {
+          if (this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9) {
+            var target = manipulationTarget(this, elem);
+            target.insertBefore(elem, target.firstChild);
+          }
+        });
+      },
+      before: function () {
+        return domManip(this, arguments, function (elem) {
+          if (this.parentNode) {
+            this.parentNode.insertBefore(elem, this);
+          }
+        });
+      },
+      after: function () {
+        return domManip(this, arguments, function (elem) {
+          if (this.parentNode) {
+            this.parentNode.insertBefore(elem, this.nextSibling);
+          }
+        });
+      },
+      empty: function () {
+        var elem,
+            i = 0;
+
+        for (; (elem = this[i]) != null; i++) {
+          if (elem.nodeType === 1) {
+            // Prevent memory leaks
+            jQuery.cleanData(getAll(elem, false)); // Remove any remaining nodes
+
+            elem.textContent = "";
+          }
+        }
+
+        return this;
+      },
+      clone: function (dataAndEvents, deepDataAndEvents) {
+        dataAndEvents = dataAndEvents == null ? false : dataAndEvents;
+        deepDataAndEvents = deepDataAndEvents == null ? dataAndEvents : deepDataAndEvents;
+        return this.map(function () {
+          return jQuery.clone(this, dataAndEvents, deepDataAndEvents);
+        });
+      },
+      html: function (value) {
+        return access(this, function (value) {
+          var elem = this[0] || {},
+              i = 0,
+              l = this.length;
+
+          if (value === undefined && elem.nodeType === 1) {
+            return elem.innerHTML;
+          } // See if we can take a shortcut and just use innerHTML
+
+
+          if (typeof value === "string" && !rnoInnerhtml.test(value) && !wrapMap[(rtagName.exec(value) || ["", ""])[1].toLowerCase()]) {
+            value = jQuery.htmlPrefilter(value);
+
+            try {
+              for (; i < l; i++) {
+                elem = this[i] || {}; // Remove element nodes and prevent memory leaks
+
+                if (elem.nodeType === 1) {
+                  jQuery.cleanData(getAll(elem, false));
+                  elem.innerHTML = value;
+                }
+              }
+
+              elem = 0; // If using innerHTML throws an exception, use the fallback method
+            } catch (e) {}
+          }
+
+          if (elem) {
+            this.empty().append(value);
+          }
+        }, null, value, arguments.length);
+      },
+      replaceWith: function () {
+        var ignored = []; // Make the changes, replacing each non-ignored context element with the new content
+
+        return domManip(this, arguments, function (elem) {
+          var parent = this.parentNode;
+
+          if (jQuery.inArray(this, ignored) < 0) {
+            jQuery.cleanData(getAll(this));
+
+            if (parent) {
+              parent.replaceChild(elem, this);
+            }
+          } // Force callback invocation
+
+        }, ignored);
+      }
+    });
+    jQuery.each({
+      appendTo: "append",
+      prependTo: "prepend",
+      insertBefore: "before",
+      insertAfter: "after",
+      replaceAll: "replaceWith"
+    }, function (name, original) {
+      jQuery.fn[name] = function (selector) {
+        var elems,
+            ret = [],
+            insert = jQuery(selector),
+            last = insert.length - 1,
+            i = 0;
+
+        for (; i <= last; i++) {
+          elems = i === last ? this : this.clone(true);
+          jQuery(insert[i])[original](elems); // Support: Android <=4.0 only, PhantomJS 1 only
+          // .get() because push.apply(_, arraylike) throws on ancient WebKit
+
+          push.apply(ret, elems.get());
+        }
+
+        return this.pushStack(ret);
+      };
+    });
+    var rnumnonpx = new RegExp("^(" + pnum + ")(?!px)[a-z%]+$", "i");
+
+    var getStyles = function (elem) {
+      // Support: IE <=11 only, Firefox <=30 (#15098, #14150)
+      // IE throws on elements created in popups
+      // FF meanwhile throws on frame elements through "defaultView.getComputedStyle"
+      var view = elem.ownerDocument.defaultView;
+
+      if (!view || !view.opener) {
+        view = window;
+      }
+
+      return view.getComputedStyle(elem);
+    };
+
+    var rboxStyle = new RegExp(cssExpand.join("|"), "i");
+
+    (function () {
+      // Executing both pixelPosition & boxSizingReliable tests require only one layout
+      // so they're executed at the same time to save the second computation.
+      function computeStyleTests() {
+        // This is a singleton, we need to execute it only once
+        if (!div) {
+          return;
+        }
+
+        container.style.cssText = "position:absolute;left:-11111px;width:60px;" + "margin-top:1px;padding:0;border:0";
+        div.style.cssText = "position:relative;display:block;box-sizing:border-box;overflow:scroll;" + "margin:auto;border:1px;padding:1px;" + "width:60%;top:1%";
+        documentElement.appendChild(container).appendChild(div);
+        var divStyle = window.getComputedStyle(div);
+        pixelPositionVal = divStyle.top !== "1%"; // Support: Android 4.0 - 4.3 only, Firefox <=3 - 44
+
+        reliableMarginLeftVal = roundPixelMeasures(divStyle.marginLeft) === 12; // Support: Android 4.0 - 4.3 only, Safari <=9.1 - 10.1, iOS <=7.0 - 9.3
+        // Some styles come back with percentage values, even though they shouldn't
+
+        div.style.right = "60%";
+        pixelBoxStylesVal = roundPixelMeasures(divStyle.right) === 36; // Support: IE 9 - 11 only
+        // Detect misreporting of content dimensions for box-sizing:border-box elements
+
+        boxSizingReliableVal = roundPixelMeasures(divStyle.width) === 36; // Support: IE 9 only
+        // Detect overflow:scroll screwiness (gh-3699)
+
+        div.style.position = "absolute";
+        scrollboxSizeVal = div.offsetWidth === 36 || "absolute";
+        documentElement.removeChild(container); // Nullify the div so it wouldn't be stored in the memory and
+        // it will also be a sign that checks already performed
+
+        div = null;
+      }
+
+      function roundPixelMeasures(measure) {
+        return Math.round(parseFloat(measure));
+      }
+
+      var pixelPositionVal,
+          boxSizingReliableVal,
+          scrollboxSizeVal,
+          pixelBoxStylesVal,
+          reliableMarginLeftVal,
+          container = document$2.createElement("div"),
+          div = document$2.createElement("div"); // Finish early in limited (non-browser) environments
+
+      if (!div.style) {
+        return;
+      } // Support: IE <=9 - 11 only
+      // Style of cloned element affects source element cloned (#8908)
+
+
+      div.style.backgroundClip = "content-box";
+      div.cloneNode(true).style.backgroundClip = "";
+      support.clearCloneStyle = div.style.backgroundClip === "content-box";
+      jQuery.extend(support, {
+        boxSizingReliable: function () {
+          computeStyleTests();
+          return boxSizingReliableVal;
+        },
+        pixelBoxStyles: function () {
+          computeStyleTests();
+          return pixelBoxStylesVal;
+        },
+        pixelPosition: function () {
+          computeStyleTests();
+          return pixelPositionVal;
+        },
+        reliableMarginLeft: function () {
+          computeStyleTests();
+          return reliableMarginLeftVal;
+        },
+        scrollboxSize: function () {
+          computeStyleTests();
+          return scrollboxSizeVal;
+        }
+      });
+    })();
+
+    function curCSS(elem, name, computed) {
+      var width,
+          minWidth,
+          maxWidth,
+          ret,
+          // Support: Firefox 51+
+      // Retrieving style before computed somehow
+      // fixes an issue with getting wrong values
+      // on detached elements
+      style = elem.style;
+      computed = computed || getStyles(elem); // getPropertyValue is needed for:
+      //   .css('filter') (IE 9 only, #12537)
+      //   .css('--customProperty) (#3144)
+
+      if (computed) {
+        ret = computed.getPropertyValue(name) || computed[name];
+
+        if (ret === "" && !jQuery.contains(elem.ownerDocument, elem)) {
+          ret = jQuery.style(elem, name);
+        } // A tribute to the "awesome hack by Dean Edwards"
+        // Android Browser returns percentage for some values,
+        // but width seems to be reliably pixels.
+        // This is against the CSSOM draft spec:
+        // https://drafts.csswg.org/cssom/#resolved-values
+
+
+        if (!support.pixelBoxStyles() && rnumnonpx.test(ret) && rboxStyle.test(name)) {
+          // Remember the original values
+          width = style.width;
+          minWidth = style.minWidth;
+          maxWidth = style.maxWidth; // Put in the new values to get a computed value out
+
+          style.minWidth = style.maxWidth = style.width = ret;
+          ret = computed.width; // Revert the changed values
+
+          style.width = width;
+          style.minWidth = minWidth;
+          style.maxWidth = maxWidth;
+        }
+      }
+
+      return ret !== undefined ? // Support: IE <=9 - 11 only
+      // IE returns zIndex value as an integer.
+      ret + "" : ret;
+    }
+
+    function addGetHookIf(conditionFn, hookFn) {
+      // Define the hook, we'll check on the first run if it's really needed.
+      return {
+        get: function () {
+          if (conditionFn()) {
+            // Hook not needed (or it's not possible to use it due
+            // to missing dependency), remove it.
+            delete this.get;
+            return;
+          } // Hook needed; redefine it so that the support test is not executed again.
+
+
+          return (this.get = hookFn).apply(this, arguments);
+        }
+      };
+    }
+
+    var // Swappable if display is none or starts with table
+    // except "table", "table-cell", or "table-caption"
+    // See here for display values: https://developer.mozilla.org/en-US/docs/CSS/display
+    rdisplayswap = /^(none|table(?!-c[ea]).+)/,
+        rcustomProp = /^--/,
+        cssShow = {
+      position: "absolute",
+      visibility: "hidden",
+      display: "block"
+    },
+        cssNormalTransform = {
+      letterSpacing: "0",
+      fontWeight: "400"
+    },
+        cssPrefixes = ["Webkit", "Moz", "ms"],
+        emptyStyle = document$2.createElement("div").style; // Return a css property mapped to a potentially vendor prefixed property
+
+    function vendorPropName(name) {
+      // Shortcut for names that are not vendor prefixed
+      if (name in emptyStyle) {
+        return name;
+      } // Check for vendor prefixed names
+
+
+      var capName = name[0].toUpperCase() + name.slice(1),
+          i = cssPrefixes.length;
+
+      while (i--) {
+        name = cssPrefixes[i] + capName;
+
+        if (name in emptyStyle) {
+          return name;
+        }
+      }
+    } // Return a property mapped along what jQuery.cssProps suggests or to
+    // a vendor prefixed property.
+
+
+    function finalPropName(name) {
+      var ret = jQuery.cssProps[name];
+
+      if (!ret) {
+        ret = jQuery.cssProps[name] = vendorPropName(name) || name;
+      }
+
+      return ret;
+    }
+
+    function setPositiveNumber(elem, value, subtract) {
+      // Any relative (+/-) values have already been
+      // normalized at this point
+      var matches = rcssNum.exec(value);
+      return matches ? // Guard against undefined "subtract", e.g., when used as in cssHooks
+      Math.max(0, matches[2] - (subtract || 0)) + (matches[3] || "px") : value;
+    }
+
+    function boxModelAdjustment(elem, dimension, box, isBorderBox, styles, computedVal) {
+      var i = dimension === "width" ? 1 : 0,
+          extra = 0,
+          delta = 0; // Adjustment may not be necessary
+
+      if (box === (isBorderBox ? "border" : "content")) {
+        return 0;
+      }
+
+      for (; i < 4; i += 2) {
+        // Both box models exclude margin
+        if (box === "margin") {
+          delta += jQuery.css(elem, box + cssExpand[i], true, styles);
+        } // If we get here with a content-box, we're seeking "padding" or "border" or "margin"
+
+
+        if (!isBorderBox) {
+          // Add padding
+          delta += jQuery.css(elem, "padding" + cssExpand[i], true, styles); // For "border" or "margin", add border
+
+          if (box !== "padding") {
+            delta += jQuery.css(elem, "border" + cssExpand[i] + "Width", true, styles); // But still keep track of it otherwise
+          } else {
+            extra += jQuery.css(elem, "border" + cssExpand[i] + "Width", true, styles);
+          } // If we get here with a border-box (content + padding + border), we're seeking "content" or
+          // "padding" or "margin"
+
+        } else {
+          // For "content", subtract padding
+          if (box === "content") {
+            delta -= jQuery.css(elem, "padding" + cssExpand[i], true, styles);
+          } // For "content" or "padding", subtract border
+
+
+          if (box !== "margin") {
+            delta -= jQuery.css(elem, "border" + cssExpand[i] + "Width", true, styles);
+          }
+        }
+      } // Account for positive content-box scroll gutter when requested by providing computedVal
+
+
+      if (!isBorderBox && computedVal >= 0) {
+        // offsetWidth/offsetHeight is a rounded sum of content, padding, scroll gutter, and border
+        // Assuming integer scroll gutter, subtract the rest and round down
+        delta += Math.max(0, Math.ceil(elem["offset" + dimension[0].toUpperCase() + dimension.slice(1)] - computedVal - delta - extra - 0.5));
+      }
+
+      return delta;
+    }
+
+    function getWidthOrHeight(elem, dimension, extra) {
+      // Start with computed style
+      var styles = getStyles(elem),
+          val = curCSS(elem, dimension, styles),
+          isBorderBox = jQuery.css(elem, "boxSizing", false, styles) === "border-box",
+          valueIsBorderBox = isBorderBox; // Support: Firefox <=54
+      // Return a confounding non-pixel value or feign ignorance, as appropriate.
+
+      if (rnumnonpx.test(val)) {
+        if (!extra) {
+          return val;
+        }
+
+        val = "auto";
+      } // Check for style in case a browser which returns unreliable values
+      // for getComputedStyle silently falls back to the reliable elem.style
+
+
+      valueIsBorderBox = valueIsBorderBox && (support.boxSizingReliable() || val === elem.style[dimension]); // Fall back to offsetWidth/offsetHeight when value is "auto"
+      // This happens for inline elements with no explicit setting (gh-3571)
+      // Support: Android <=4.1 - 4.3 only
+      // Also use offsetWidth/offsetHeight for misreported inline dimensions (gh-3602)
+
+      if (val === "auto" || !parseFloat(val) && jQuery.css(elem, "display", false, styles) === "inline") {
+        val = elem["offset" + dimension[0].toUpperCase() + dimension.slice(1)]; // offsetWidth/offsetHeight provide border-box values
+
+        valueIsBorderBox = true;
+      } // Normalize "" and auto
+
+
+      val = parseFloat(val) || 0; // Adjust for the element's box model
+
+      return val + boxModelAdjustment(elem, dimension, extra || (isBorderBox ? "border" : "content"), valueIsBorderBox, styles, // Provide the current computed size to request scroll gutter calculation (gh-3589)
+      val) + "px";
+    }
+
+    jQuery.extend({
+      // Add in style property hooks for overriding the default
+      // behavior of getting and setting a style property
+      cssHooks: {
+        opacity: {
+          get: function (elem, computed) {
+            if (computed) {
+              // We should always get a number back from opacity
+              var ret = curCSS(elem, "opacity");
+              return ret === "" ? "1" : ret;
+            }
+          }
+        }
+      },
+      // Don't automatically add "px" to these possibly-unitless properties
+      cssNumber: {
+        "animationIterationCount": true,
+        "columnCount": true,
+        "fillOpacity": true,
+        "flexGrow": true,
+        "flexShrink": true,
+        "fontWeight": true,
+        "lineHeight": true,
+        "opacity": true,
+        "order": true,
+        "orphans": true,
+        "widows": true,
+        "zIndex": true,
+        "zoom": true
+      },
+      // Add in properties whose names you wish to fix before
+      // setting or getting the value
+      cssProps: {},
+      // Get and set the style property on a DOM Node
+      style: function (elem, name, value, extra) {
+        // Don't set styles on text and comment nodes
+        if (!elem || elem.nodeType === 3 || elem.nodeType === 8 || !elem.style) {
+          return;
+        } // Make sure that we're working with the right name
+
+
+        var ret,
+            type,
+            hooks,
+            origName = camelCase(name),
+            isCustomProp = rcustomProp.test(name),
+            style = elem.style; // Make sure that we're working with the right name. We don't
+        // want to query the value if it is a CSS custom property
+        // since they are user-defined.
+
+        if (!isCustomProp) {
+          name = finalPropName(origName);
+        } // Gets hook for the prefixed version, then unprefixed version
+
+
+        hooks = jQuery.cssHooks[name] || jQuery.cssHooks[origName]; // Check if we're setting a value
+
+        if (value !== undefined) {
+          type = typeof value; // Convert "+=" or "-=" to relative numbers (#7345)
+
+          if (type === "string" && (ret = rcssNum.exec(value)) && ret[1]) {
+            value = adjustCSS(elem, name, ret); // Fixes bug #9237
+
+            type = "number";
+          } // Make sure that null and NaN values aren't set (#7116)
+
+
+          if (value == null || value !== value) {
+            return;
+          } // If a number was passed in, add the unit (except for certain CSS properties)
+
+
+          if (type === "number") {
+            value += ret && ret[3] || (jQuery.cssNumber[origName] ? "" : "px");
+          } // background-* props affect original clone's values
+
+
+          if (!support.clearCloneStyle && value === "" && name.indexOf("background") === 0) {
+            style[name] = "inherit";
+          } // If a hook was provided, use that value, otherwise just set the specified value
+
+
+          if (!hooks || !("set" in hooks) || (value = hooks.set(elem, value, extra)) !== undefined) {
+            if (isCustomProp) {
+              style.setProperty(name, value);
+            } else {
+              style[name] = value;
+            }
+          }
+        } else {
+          // If a hook was provided get the non-computed value from there
+          if (hooks && "get" in hooks && (ret = hooks.get(elem, false, extra)) !== undefined) {
+            return ret;
+          } // Otherwise just get the value from the style object
+
+
+          return style[name];
+        }
+      },
+      css: function (elem, name, extra, styles) {
+        var val,
+            num,
+            hooks,
+            origName = camelCase(name),
+            isCustomProp = rcustomProp.test(name); // Make sure that we're working with the right name. We don't
+        // want to modify the value if it is a CSS custom property
+        // since they are user-defined.
+
+        if (!isCustomProp) {
+          name = finalPropName(origName);
+        } // Try prefixed name followed by the unprefixed name
+
+
+        hooks = jQuery.cssHooks[name] || jQuery.cssHooks[origName]; // If a hook was provided get the computed value from there
+
+        if (hooks && "get" in hooks) {
+          val = hooks.get(elem, true, extra);
+        } // Otherwise, if a way to get the computed value exists, use that
+
+
+        if (val === undefined) {
+          val = curCSS(elem, name, styles);
+        } // Convert "normal" to computed value
+
+
+        if (val === "normal" && name in cssNormalTransform) {
+          val = cssNormalTransform[name];
+        } // Make numeric if forced or a qualifier was provided and val looks numeric
+
+
+        if (extra === "" || extra) {
+          num = parseFloat(val);
+          return extra === true || isFinite(num) ? num || 0 : val;
+        }
+
+        return val;
+      }
+    });
+    jQuery.each(["height", "width"], function (i, dimension) {
+      jQuery.cssHooks[dimension] = {
+        get: function (elem, computed, extra) {
+          if (computed) {
+            // Certain elements can have dimension info if we invisibly show them
+            // but it must have a current display style that would benefit
+            return rdisplayswap.test(jQuery.css(elem, "display")) && (!elem.getClientRects().length || !elem.getBoundingClientRect().width) ? swap(elem, cssShow, function () {
+              return getWidthOrHeight(elem, dimension, extra);
+            }) : getWidthOrHeight(elem, dimension, extra);
+          }
+        },
+        set: function (elem, value, extra) {
+          var matches,
+              styles = getStyles(elem),
+              isBorderBox = jQuery.css(elem, "boxSizing", false, styles) === "border-box",
+              subtract = extra && boxModelAdjustment(elem, dimension, extra, isBorderBox, styles); // Account for unreliable border-box dimensions by comparing offset* to computed and
+          // faking a content-box to get border and padding (gh-3699)
+
+          if (isBorderBox && support.scrollboxSize() === styles.position) {
+            subtract -= Math.ceil(elem["offset" + dimension[0].toUpperCase() + dimension.slice(1)] - parseFloat(styles[dimension]) - boxModelAdjustment(elem, dimension, "border", false, styles) - 0.5);
+          } // Convert to pixels if value adjustment is needed
+
+
+          if (subtract && (matches = rcssNum.exec(value)) && (matches[3] || "px") !== "px") {
+            elem.style[dimension] = value;
+            value = jQuery.css(elem, dimension);
+          }
+
+          return setPositiveNumber(elem, value, subtract);
+        }
+      };
+    });
+    jQuery.cssHooks.marginLeft = addGetHookIf(support.reliableMarginLeft, function (elem, computed) {
+      if (computed) {
+        return (parseFloat(curCSS(elem, "marginLeft")) || elem.getBoundingClientRect().left - swap(elem, {
+          marginLeft: 0
+        }, function () {
+          return elem.getBoundingClientRect().left;
+        })) + "px";
+      }
+    }); // These hooks are used by animate to expand properties
+
+    jQuery.each({
+      margin: "",
+      padding: "",
+      border: "Width"
+    }, function (prefix, suffix) {
+      jQuery.cssHooks[prefix + suffix] = {
+        expand: function (value) {
+          var i = 0,
+              expanded = {},
+              // Assumes a single number if not a string
+          parts = typeof value === "string" ? value.split(" ") : [value];
+
+          for (; i < 4; i++) {
+            expanded[prefix + cssExpand[i] + suffix] = parts[i] || parts[i - 2] || parts[0];
+          }
+
+          return expanded;
+        }
+      };
+
+      if (prefix !== "margin") {
+        jQuery.cssHooks[prefix + suffix].set = setPositiveNumber;
+      }
+    });
+    jQuery.fn.extend({
+      css: function (name, value) {
+        return access(this, function (elem, name, value) {
+          var styles,
+              len,
+              map = {},
+              i = 0;
+
+          if (Array.isArray(name)) {
+            styles = getStyles(elem);
+            len = name.length;
+
+            for (; i < len; i++) {
+              map[name[i]] = jQuery.css(elem, name[i], false, styles);
+            }
+
+            return map;
+          }
+
+          return value !== undefined ? jQuery.style(elem, name, value) : jQuery.css(elem, name);
+        }, name, value, arguments.length > 1);
+      }
+    }); // Based off of the plugin by Clint Helfers, with permission.
+    // https://web.archive.org/web/20100324014747/http://blindsignals.com/index.php/2009/07/jquery-delay/
+
+    jQuery.fn.delay = function (time, type) {
+      time = jQuery.fx ? jQuery.fx.speeds[time] || time : time;
+      type = type || "fx";
+      return this.queue(type, function (next, hooks) {
+        var timeout = window.setTimeout(next, time);
+
+        hooks.stop = function () {
+          window.clearTimeout(timeout);
+        };
+      });
+    };
+
+    (function () {
+      var input = document$2.createElement("input"),
+          select = document$2.createElement("select"),
+          opt = select.appendChild(document$2.createElement("option"));
+      input.type = "checkbox"; // Support: Android <=4.3 only
+      // Default value for a checkbox should be "on"
+
+      support.checkOn = input.value !== ""; // Support: IE <=11 only
+      // Must access selectedIndex to make default options select
+
+      support.optSelected = opt.selected; // Support: IE <=11 only
+      // An input loses its value after becoming a radio
+
+      input = document$2.createElement("input");
+      input.value = "t";
+      input.type = "radio";
+      support.radioValue = input.value === "t";
+    })();
+
+    var boolHook,
+        attrHandle = jQuery.expr.attrHandle;
+    jQuery.fn.extend({
+      attr: function (name, value) {
+        return access(this, jQuery.attr, name, value, arguments.length > 1);
+      },
+      removeAttr: function (name) {
+        return this.each(function () {
+          jQuery.removeAttr(this, name);
+        });
+      }
+    });
+    jQuery.extend({
+      attr: function (elem, name, value) {
+        var ret,
+            hooks,
+            nType = elem.nodeType; // Don't get/set attributes on text, comment and attribute nodes
+
+        if (nType === 3 || nType === 8 || nType === 2) {
+          return;
+        } // Fallback to prop when attributes are not supported
+
+
+        if (typeof elem.getAttribute === "undefined") {
+          return jQuery.prop(elem, name, value);
+        } // Attribute hooks are determined by the lowercase version
+        // Grab necessary hook if one is defined
+
+
+        if (nType !== 1 || !jQuery.isXMLDoc(elem)) {
+          hooks = jQuery.attrHooks[name.toLowerCase()] || (jQuery.expr.match.bool.test(name) ? boolHook : undefined);
+        }
+
+        if (value !== undefined) {
+          if (value === null) {
+            jQuery.removeAttr(elem, name);
+            return;
+          }
+
+          if (hooks && "set" in hooks && (ret = hooks.set(elem, value, name)) !== undefined) {
+            return ret;
+          }
+
+          elem.setAttribute(name, value + "");
+          return value;
+        }
+
+        if (hooks && "get" in hooks && (ret = hooks.get(elem, name)) !== null) {
+          return ret;
+        }
+
+        ret = jQuery.find.attr(elem, name); // Non-existent attributes return null, we normalize to undefined
+
+        return ret == null ? undefined : ret;
+      },
+      attrHooks: {
+        type: {
+          set: function (elem, value) {
+            if (!support.radioValue && value === "radio" && nodeName(elem, "input")) {
+              var val = elem.value;
+              elem.setAttribute("type", value);
+
+              if (val) {
+                elem.value = val;
+              }
+
+              return value;
+            }
+          }
+        }
+      },
+      removeAttr: function (elem, value) {
+        var name,
+            i = 0,
+            // Attribute names can contain non-HTML whitespace characters
+        // https://html.spec.whatwg.org/multipage/syntax.html#attributes-2
+        attrNames = value && value.match(rnothtmlwhite);
+
+        if (attrNames && elem.nodeType === 1) {
+          while (name = attrNames[i++]) {
+            elem.removeAttribute(name);
+          }
+        }
+      }
+    }); // Hooks for boolean attributes
+
+    boolHook = {
+      set: function (elem, value, name) {
+        if (value === false) {
+          // Remove boolean attributes when set to false
+          jQuery.removeAttr(elem, name);
+        } else {
+          elem.setAttribute(name, name);
+        }
+
+        return name;
+      }
+    };
+    jQuery.each(jQuery.expr.match.bool.source.match(/\w+/g), function (i, name) {
+      var getter = attrHandle[name] || jQuery.find.attr;
+
+      attrHandle[name] = function (elem, name, isXML) {
+        var ret,
+            handle,
+            lowercaseName = name.toLowerCase();
+
+        if (!isXML) {
+          // Avoid an infinite loop by temporarily removing this function from the getter
+          handle = attrHandle[lowercaseName];
+          attrHandle[lowercaseName] = ret;
+          ret = getter(elem, name, isXML) != null ? lowercaseName : null;
+          attrHandle[lowercaseName] = handle;
+        }
+
+        return ret;
+      };
+    });
+    var rfocusable = /^(?:input|select|textarea|button)$/i,
+        rclickable = /^(?:a|area)$/i;
+    jQuery.fn.extend({
+      prop: function (name, value) {
+        return access(this, jQuery.prop, name, value, arguments.length > 1);
+      },
+      removeProp: function (name) {
+        return this.each(function () {
+          delete this[jQuery.propFix[name] || name];
+        });
+      }
+    });
+    jQuery.extend({
+      prop: function (elem, name, value) {
+        var ret,
+            hooks,
+            nType = elem.nodeType; // Don't get/set properties on text, comment and attribute nodes
+
+        if (nType === 3 || nType === 8 || nType === 2) {
+          return;
+        }
+
+        if (nType !== 1 || !jQuery.isXMLDoc(elem)) {
+          // Fix name and attach hooks
+          name = jQuery.propFix[name] || name;
+          hooks = jQuery.propHooks[name];
+        }
+
+        if (value !== undefined) {
+          if (hooks && "set" in hooks && (ret = hooks.set(elem, value, name)) !== undefined) {
+            return ret;
+          }
+
+          return elem[name] = value;
+        }
+
+        if (hooks && "get" in hooks && (ret = hooks.get(elem, name)) !== null) {
+          return ret;
+        }
+
+        return elem[name];
+      },
+      propHooks: {
+        tabIndex: {
+          get: function (elem) {
+            // Support: IE <=9 - 11 only
+            // elem.tabIndex doesn't always return the
+            // correct value when it hasn't been explicitly set
+            // https://web.archive.org/web/20141116233347/http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/
+            // Use proper attribute retrieval(#12072)
+            var tabindex = jQuery.find.attr(elem, "tabindex");
+
+            if (tabindex) {
+              return parseInt(tabindex, 10);
+            }
+
+            if (rfocusable.test(elem.nodeName) || rclickable.test(elem.nodeName) && elem.href) {
+              return 0;
+            }
+
+            return -1;
+          }
+        }
+      },
+      propFix: {
+        "for": "htmlFor",
+        "class": "className"
+      }
+    }); // Support: IE <=11 only
+    // Accessing the selectedIndex property
+    // forces the browser to respect setting selected
+    // on the option
+    // The getter ensures a default option is selected
+    // when in an optgroup
+    // eslint rule "no-unused-expressions" is disabled for this code
+    // since it considers such accessions noop
+
+    if (!support.optSelected) {
+      jQuery.propHooks.selected = {
+        get: function (elem) {
+          /* eslint no-unused-expressions: "off" */
+          var parent = elem.parentNode;
+
+          if (parent && parent.parentNode) {
+            parent.parentNode.selectedIndex;
+          }
+
+          return null;
+        },
+        set: function (elem) {
+          /* eslint no-unused-expressions: "off" */
+          var parent = elem.parentNode;
+
+          if (parent) {
+            parent.selectedIndex;
+
+            if (parent.parentNode) {
+              parent.parentNode.selectedIndex;
+            }
+          }
+        }
+      };
+    }
+
+    jQuery.each(["tabIndex", "readOnly", "maxLength", "cellSpacing", "cellPadding", "rowSpan", "colSpan", "useMap", "frameBorder", "contentEditable"], function () {
+      jQuery.propFix[this.toLowerCase()] = this;
+    }); // Strip and collapse whitespace according to HTML spec
+    // https://infra.spec.whatwg.org/#strip-and-collapse-ascii-whitespace
+
+    function stripAndCollapse(value) {
+      var tokens = value.match(rnothtmlwhite) || [];
+      return tokens.join(" ");
+    }
+
+    function getClass(elem) {
+      return elem.getAttribute && elem.getAttribute("class") || "";
+    }
+
+    function classesToArray(value) {
+      if (Array.isArray(value)) {
+        return value;
+      }
+
+      if (typeof value === "string") {
+        return value.match(rnothtmlwhite) || [];
+      }
+
+      return [];
+    }
+
+    jQuery.fn.extend({
+      addClass: function (value) {
+        var classes,
+            elem,
+            cur,
+            curValue,
+            clazz,
+            j,
+            finalValue,
+            i = 0;
+
+        if (isFunction(value)) {
+          return this.each(function (j) {
+            jQuery(this).addClass(value.call(this, j, getClass(this)));
+          });
+        }
+
+        classes = classesToArray(value);
+
+        if (classes.length) {
+          while (elem = this[i++]) {
+            curValue = getClass(elem);
+            cur = elem.nodeType === 1 && " " + stripAndCollapse(curValue) + " ";
+
+            if (cur) {
+              j = 0;
+
+              while (clazz = classes[j++]) {
+                if (cur.indexOf(" " + clazz + " ") < 0) {
+                  cur += clazz + " ";
+                }
+              } // Only assign if different to avoid unneeded rendering.
+
+
+              finalValue = stripAndCollapse(cur);
+
+              if (curValue !== finalValue) {
+                elem.setAttribute("class", finalValue);
+              }
+            }
+          }
+        }
+
+        return this;
+      },
+      removeClass: function (value) {
+        var classes,
+            elem,
+            cur,
+            curValue,
+            clazz,
+            j,
+            finalValue,
+            i = 0;
+
+        if (isFunction(value)) {
+          return this.each(function (j) {
+            jQuery(this).removeClass(value.call(this, j, getClass(this)));
+          });
+        }
+
+        if (!arguments.length) {
+          return this.attr("class", "");
+        }
+
+        classes = classesToArray(value);
+
+        if (classes.length) {
+          while (elem = this[i++]) {
+            curValue = getClass(elem); // This expression is here for better compressibility (see addClass)
+
+            cur = elem.nodeType === 1 && " " + stripAndCollapse(curValue) + " ";
+
+            if (cur) {
+              j = 0;
+
+              while (clazz = classes[j++]) {
+                // Remove *all* instances
+                while (cur.indexOf(" " + clazz + " ") > -1) {
+                  cur = cur.replace(" " + clazz + " ", " ");
+                }
+              } // Only assign if different to avoid unneeded rendering.
+
+
+              finalValue = stripAndCollapse(cur);
+
+              if (curValue !== finalValue) {
+                elem.setAttribute("class", finalValue);
+              }
+            }
+          }
+        }
+
+        return this;
+      },
+      toggleClass: function (value, stateVal) {
+        var type = typeof value,
+            isValidValue = type === "string" || Array.isArray(value);
+
+        if (typeof stateVal === "boolean" && isValidValue) {
+          return stateVal ? this.addClass(value) : this.removeClass(value);
+        }
+
+        if (isFunction(value)) {
+          return this.each(function (i) {
+            jQuery(this).toggleClass(value.call(this, i, getClass(this), stateVal), stateVal);
+          });
+        }
+
+        return this.each(function () {
+          var className, i, self, classNames;
+
+          if (isValidValue) {
+            // Toggle individual class names
+            i = 0;
+            self = jQuery(this);
+            classNames = classesToArray(value);
+
+            while (className = classNames[i++]) {
+              // Check each className given, space separated list
+              if (self.hasClass(className)) {
+                self.removeClass(className);
+              } else {
+                self.addClass(className);
+              }
+            } // Toggle whole class name
+
+          } else if (value === undefined || type === "boolean") {
+            className = getClass(this);
+
+            if (className) {
+              // Store className if set
+              dataPriv.set(this, "__className__", className);
+            } // If the element has a class name or if we're passed `false`,
+            // then remove the whole classname (if there was one, the above saved it).
+            // Otherwise bring back whatever was previously saved (if anything),
+            // falling back to the empty string if nothing was stored.
+
+
+            if (this.setAttribute) {
+              this.setAttribute("class", className || value === false ? "" : dataPriv.get(this, "__className__") || "");
+            }
+          }
+        });
+      },
+      hasClass: function (selector) {
+        var className,
+            elem,
+            i = 0;
+        className = " " + selector + " ";
+
+        while (elem = this[i++]) {
+          if (elem.nodeType === 1 && (" " + stripAndCollapse(getClass(elem)) + " ").indexOf(className) > -1) {
+            return true;
+          }
+        }
+
+        return false;
+      }
+    });
+    var rreturn = /\r/g;
+    jQuery.fn.extend({
+      val: function (value) {
+        var hooks,
+            ret,
+            valueIsFunction,
+            elem = this[0];
+
+        if (!arguments.length) {
+          if (elem) {
+            hooks = jQuery.valHooks[elem.type] || jQuery.valHooks[elem.nodeName.toLowerCase()];
+
+            if (hooks && "get" in hooks && (ret = hooks.get(elem, "value")) !== undefined) {
+              return ret;
+            }
+
+            ret = elem.value; // Handle most common string cases
+
+            if (typeof ret === "string") {
+              return ret.replace(rreturn, "");
+            } // Handle cases where value is null/undef or number
+
+
+            return ret == null ? "" : ret;
+          }
+
+          return;
+        }
+
+        valueIsFunction = isFunction(value);
+        return this.each(function (i) {
+          var val;
+
+          if (this.nodeType !== 1) {
+            return;
+          }
+
+          if (valueIsFunction) {
+            val = value.call(this, i, jQuery(this).val());
+          } else {
+            val = value;
+          } // Treat null/undefined as ""; convert numbers to string
+
+
+          if (val == null) {
+            val = "";
+          } else if (typeof val === "number") {
+            val += "";
+          } else if (Array.isArray(val)) {
+            val = jQuery.map(val, function (value) {
+              return value == null ? "" : value + "";
+            });
+          }
+
+          hooks = jQuery.valHooks[this.type] || jQuery.valHooks[this.nodeName.toLowerCase()]; // If set returns undefined, fall back to normal setting
+
+          if (!hooks || !("set" in hooks) || hooks.set(this, val, "value") === undefined) {
+            this.value = val;
+          }
+        });
+      }
+    });
+    jQuery.extend({
+      valHooks: {
+        option: {
+          get: function (elem) {
+            var val = jQuery.find.attr(elem, "value");
+            return val != null ? val : // Support: IE <=10 - 11 only
+            // option.text throws exceptions (#14686, #14858)
+            // Strip and collapse whitespace
+            // https://html.spec.whatwg.org/#strip-and-collapse-whitespace
+            stripAndCollapse(jQuery.text(elem));
+          }
+        },
+        select: {
+          get: function (elem) {
+            var value,
+                option,
+                i,
+                options = elem.options,
+                index = elem.selectedIndex,
+                one = elem.type === "select-one",
+                values = one ? null : [],
+                max = one ? index + 1 : options.length;
+
+            if (index < 0) {
+              i = max;
+            } else {
+              i = one ? index : 0;
+            } // Loop through all the selected options
+
+
+            for (; i < max; i++) {
+              option = options[i]; // Support: IE <=9 only
+              // IE8-9 doesn't update selected after form reset (#2551)
+
+              if ((option.selected || i === index) && // Don't return options that are disabled or in a disabled optgroup
+              !option.disabled && (!option.parentNode.disabled || !nodeName(option.parentNode, "optgroup"))) {
+                // Get the specific value for the option
+                value = jQuery(option).val(); // We don't need an array for one selects
+
+                if (one) {
+                  return value;
+                } // Multi-Selects return an array
+
+
+                values.push(value);
+              }
+            }
+
+            return values;
+          },
+          set: function (elem, value) {
+            var optionSet,
+                option,
+                options = elem.options,
+                values = jQuery.makeArray(value),
+                i = options.length;
+
+            while (i--) {
+              option = options[i];
+              /* eslint-disable no-cond-assign */
+
+              if (option.selected = jQuery.inArray(jQuery.valHooks.option.get(option), values) > -1) {
+                optionSet = true;
+              }
+              /* eslint-enable no-cond-assign */
+
+            } // Force browsers to behave consistently when non-matching value is set
+
+
+            if (!optionSet) {
+              elem.selectedIndex = -1;
+            }
+
+            return values;
+          }
+        }
+      }
+    }); // Radios and checkboxes getter/setter
+
+    jQuery.each(["radio", "checkbox"], function () {
+      jQuery.valHooks[this] = {
+        set: function (elem, value) {
+          if (Array.isArray(value)) {
+            return elem.checked = jQuery.inArray(jQuery(elem).val(), value) > -1;
+          }
+        }
+      };
+
+      if (!support.checkOn) {
+        jQuery.valHooks[this].get = function (elem) {
+          return elem.getAttribute("value") === null ? "on" : elem.value;
+        };
+      }
+    }); // Return jQuery for attributes-only inclusion
+
+    support.focusin = "onfocusin" in window;
+
+    var rfocusMorph = /^(?:focusinfocus|focusoutblur)$/,
+        stopPropagationCallback = function (e) {
+      e.stopPropagation();
+    };
+
+    jQuery.extend(jQuery.event, {
+      trigger: function (event, data, elem, onlyHandlers) {
+        var i,
+            cur,
+            tmp,
+            bubbleType,
+            ontype,
+            handle,
+            special,
+            lastElement,
+            eventPath = [elem || document$2],
+            type = hasOwn.call(event, "type") ? event.type : event,
+            namespaces = hasOwn.call(event, "namespace") ? event.namespace.split(".") : [];
+        cur = lastElement = tmp = elem = elem || document$2; // Don't do events on text and comment nodes
+
+        if (elem.nodeType === 3 || elem.nodeType === 8) {
+          return;
+        } // focus/blur morphs to focusin/out; ensure we're not firing them right now
+
+
+        if (rfocusMorph.test(type + jQuery.event.triggered)) {
+          return;
+        }
+
+        if (type.indexOf(".") > -1) {
+          // Namespaced trigger; create a regexp to match event type in handle()
+          namespaces = type.split(".");
+          type = namespaces.shift();
+          namespaces.sort();
+        }
+
+        ontype = type.indexOf(":") < 0 && "on" + type; // Caller can pass in a jQuery.Event object, Object, or just an event type string
+
+        event = event[jQuery.expando] ? event : new jQuery.Event(type, typeof event === "object" && event); // Trigger bitmask: & 1 for native handlers; & 2 for jQuery (always true)
+
+        event.isTrigger = onlyHandlers ? 2 : 3;
+        event.namespace = namespaces.join(".");
+        event.rnamespace = event.namespace ? new RegExp("(^|\\.)" + namespaces.join("\\.(?:.*\\.|)") + "(\\.|$)") : null; // Clean up the event in case it is being reused
+
+        event.result = undefined;
+
+        if (!event.target) {
+          event.target = elem;
+        } // Clone any incoming data and prepend the event, creating the handler arg list
+
+
+        data = data == null ? [event] : jQuery.makeArray(data, [event]); // Allow special events to draw outside the lines
+
+        special = jQuery.event.special[type] || {};
+
+        if (!onlyHandlers && special.trigger && special.trigger.apply(elem, data) === false) {
+          return;
+        } // Determine event propagation path in advance, per W3C events spec (#9951)
+        // Bubble up to document, then to window; watch for a global ownerDocument var (#9724)
+
+
+        if (!onlyHandlers && !special.noBubble && !isWindow(elem)) {
+          bubbleType = special.delegateType || type;
+
+          if (!rfocusMorph.test(bubbleType + type)) {
+            cur = cur.parentNode;
+          }
+
+          for (; cur; cur = cur.parentNode) {
+            eventPath.push(cur);
+            tmp = cur;
+          } // Only add window if we got to document (e.g., not plain obj or detached DOM)
+
+
+          if (tmp === (elem.ownerDocument || document$2)) {
+            eventPath.push(tmp.defaultView || tmp.parentWindow || window);
+          }
+        } // Fire handlers on the event path
+
+
+        i = 0;
+
+        while ((cur = eventPath[i++]) && !event.isPropagationStopped()) {
+          lastElement = cur;
+          event.type = i > 1 ? bubbleType : special.bindType || type; // jQuery handler
+
+          handle = (dataPriv.get(cur, "events") || {})[event.type] && dataPriv.get(cur, "handle");
+
+          if (handle) {
+            handle.apply(cur, data);
+          } // Native handler
+
+
+          handle = ontype && cur[ontype];
+
+          if (handle && handle.apply && acceptData(cur)) {
+            event.result = handle.apply(cur, data);
+
+            if (event.result === false) {
+              event.preventDefault();
+            }
+          }
+        }
+
+        event.type = type; // If nobody prevented the default action, do it now
+
+        if (!onlyHandlers && !event.isDefaultPrevented()) {
+          if ((!special._default || special._default.apply(eventPath.pop(), data) === false) && acceptData(elem)) {
+            // Call a native DOM method on the target with the same name as the event.
+            // Don't do default actions on window, that's where global variables be (#6170)
+            if (ontype && isFunction(elem[type]) && !isWindow(elem)) {
+              // Don't re-trigger an onFOO event when we call its FOO() method
+              tmp = elem[ontype];
+
+              if (tmp) {
+                elem[ontype] = null;
+              } // Prevent re-triggering of the same event, since we already bubbled it above
+
+
+              jQuery.event.triggered = type;
+
+              if (event.isPropagationStopped()) {
+                lastElement.addEventListener(type, stopPropagationCallback);
+              }
+
+              elem[type]();
+
+              if (event.isPropagationStopped()) {
+                lastElement.removeEventListener(type, stopPropagationCallback);
+              }
+
+              jQuery.event.triggered = undefined;
+
+              if (tmp) {
+                elem[ontype] = tmp;
+              }
+            }
+          }
+        }
+
+        return event.result;
+      },
+      // Piggyback on a donor event to simulate a different one
+      // Used only for `focus(in | out)` events
+      simulate: function (type, elem, event) {
+        var e = jQuery.extend(new jQuery.Event(), event, {
+          type: type,
+          isSimulated: true
+        });
+        jQuery.event.trigger(e, null, elem);
+      }
+    });
+    jQuery.fn.extend({
+      trigger: function (type, data) {
+        return this.each(function () {
+          jQuery.event.trigger(type, data, this);
+        });
+      },
+      triggerHandler: function (type, data) {
+        var elem = this[0];
+
+        if (elem) {
+          return jQuery.event.trigger(type, data, elem, true);
+        }
+      }
+    }); // Support: Firefox <=44
+    // Firefox doesn't have focus(in | out) events
+    // Related ticket - https://bugzilla.mozilla.org/show_bug.cgi?id=687787
+    //
+    // Support: Chrome <=48 - 49, Safari <=9.0 - 9.1
+    // focus(in | out) events fire after focus & blur events,
+    // which is spec violation - http://www.w3.org/TR/DOM-Level-3-Events/#events-focusevent-event-order
+    // Related ticket - https://bugs.chromium.org/p/chromium/issues/detail?id=449857
+
+    if (!support.focusin) {
+      jQuery.each({
+        focus: "focusin",
+        blur: "focusout"
+      }, function (orig, fix) {
+        // Attach a single capturing handler on the document while someone wants focusin/focusout
+        var handler = function (event) {
+          jQuery.event.simulate(fix, event.target, jQuery.event.fix(event));
+        };
+
+        jQuery.event.special[fix] = {
+          setup: function () {
+            var doc = this.ownerDocument || this,
+                attaches = dataPriv.access(doc, fix);
+
+            if (!attaches) {
+              doc.addEventListener(orig, handler, true);
+            }
+
+            dataPriv.access(doc, fix, (attaches || 0) + 1);
+          },
+          teardown: function () {
+            var doc = this.ownerDocument || this,
+                attaches = dataPriv.access(doc, fix) - 1;
+
+            if (!attaches) {
+              doc.removeEventListener(orig, handler, true);
+              dataPriv.remove(doc, fix);
+            } else {
+              dataPriv.access(doc, fix, attaches);
+            }
+          }
+        };
+      });
+    }
+
+    var rbracket = /\[\]$/,
+        rCRLF = /\r?\n/g,
+        rsubmitterTypes = /^(?:submit|button|image|reset|file)$/i,
+        rsubmittable = /^(?:input|select|textarea|keygen)/i;
+
+    function buildParams(prefix, obj, traditional, add) {
+      var name;
+
+      if (Array.isArray(obj)) {
+        // Serialize array item.
+        jQuery.each(obj, function (i, v) {
+          if (traditional || rbracket.test(prefix)) {
+            // Treat each array item as a scalar.
+            add(prefix, v);
+          } else {
+            // Item is non-scalar (array or object), encode its numeric index.
+            buildParams(prefix + "[" + (typeof v === "object" && v != null ? i : "") + "]", v, traditional, add);
+          }
+        });
+      } else if (!traditional && toType(obj) === "object") {
+        // Serialize object item.
+        for (name in obj) {
+          buildParams(prefix + "[" + name + "]", obj[name], traditional, add);
+        }
+      } else {
+        // Serialize scalar item.
+        add(prefix, obj);
+      }
+    } // Serialize an array of form elements or a set of
+    // key/values into a query string
+
+
+    jQuery.param = function (a, traditional) {
+      var prefix,
+          s = [],
+          add = function (key, valueOrFunction) {
+        // If value is a function, invoke it and use its return value
+        var value = isFunction(valueOrFunction) ? valueOrFunction() : valueOrFunction;
+        s[s.length] = encodeURIComponent(key) + "=" + encodeURIComponent(value == null ? "" : value);
+      }; // If an array was passed in, assume that it is an array of form elements.
+
+
+      if (Array.isArray(a) || a.jquery && !jQuery.isPlainObject(a)) {
+        // Serialize the form elements
+        jQuery.each(a, function () {
+          add(this.name, this.value);
+        });
+      } else {
+        // If traditional, encode the "old" way (the way 1.3.2 or older
+        // did it), otherwise encode params recursively.
+        for (prefix in a) {
+          buildParams(prefix, a[prefix], traditional, add);
+        }
+      } // Return the resulting serialization
+
+
+      return s.join("&");
+    };
+
+    jQuery.fn.extend({
+      serialize: function () {
+        return jQuery.param(this.serializeArray());
+      },
+      serializeArray: function () {
+        return this.map(function () {
+          // Can add propHook for "elements" to filter or add form elements
+          var elements = jQuery.prop(this, "elements");
+          return elements ? jQuery.makeArray(elements) : this;
+        }).filter(function () {
+          var type = this.type; // Use .is( ":disabled" ) so that fieldset[disabled] works
+
+          return this.name && !jQuery(this).is(":disabled") && rsubmittable.test(this.nodeName) && !rsubmitterTypes.test(type) && (this.checked || !rcheckableType.test(type));
+        }).map(function (i, elem) {
+          var val = jQuery(this).val();
+
+          if (val == null) {
+            return null;
+          }
+
+          if (Array.isArray(val)) {
+            return jQuery.map(val, function (val) {
+              return {
+                name: elem.name,
+                value: val.replace(rCRLF, "\r\n")
+              };
+            });
+          }
+
+          return {
+            name: elem.name,
+            value: val.replace(rCRLF, "\r\n")
+          };
+        }).get();
+      }
+    });
+    jQuery.fn.extend({
+      wrapAll: function (html) {
+        var wrap;
+
+        if (this[0]) {
+          if (isFunction(html)) {
+            html = html.call(this[0]);
+          } // The elements to wrap the target around
+
+
+          wrap = jQuery(html, this[0].ownerDocument).eq(0).clone(true);
+
+          if (this[0].parentNode) {
+            wrap.insertBefore(this[0]);
+          }
+
+          wrap.map(function () {
+            var elem = this;
+
+            while (elem.firstElementChild) {
+              elem = elem.firstElementChild;
+            }
+
+            return elem;
+          }).append(this);
+        }
+
+        return this;
+      },
+      wrapInner: function (html) {
+        if (isFunction(html)) {
+          return this.each(function (i) {
+            jQuery(this).wrapInner(html.call(this, i));
+          });
+        }
+
+        return this.each(function () {
+          var self = jQuery(this),
+              contents = self.contents();
+
+          if (contents.length) {
+            contents.wrapAll(html);
+          } else {
+            self.append(html);
+          }
+        });
+      },
+      wrap: function (html) {
+        var htmlIsFunction = isFunction(html);
+        return this.each(function (i) {
+          jQuery(this).wrapAll(htmlIsFunction ? html.call(this, i) : html);
+        });
+      },
+      unwrap: function (selector) {
+        this.parent(selector).not("body").each(function () {
+          jQuery(this).replaceWith(this.childNodes);
+        });
+        return this;
+      }
+    });
+
+    jQuery.expr.pseudos.hidden = function (elem) {
+      return !jQuery.expr.pseudos.visible(elem);
+    };
+
+    jQuery.expr.pseudos.visible = function (elem) {
+      return !!(elem.offsetWidth || elem.offsetHeight || elem.getClientRects().length);
+    }; // Support: Safari 8 only
+    // In Safari 8 documents created via document.implementation.createHTMLDocument
+    // collapse sibling forms: the second one becomes a child of the first one.
+    // Because of that, this security measure has to be disabled in Safari 8.
+    // https://bugs.webkit.org/show_bug.cgi?id=137337
+
+
+    support.createHTMLDocument = function () {
+      var body = document$2.implementation.createHTMLDocument("").body;
+      body.innerHTML = "<form></form><form></form>";
+      return body.childNodes.length === 2;
+    }(); // Argument "data" should be string of html
+    // context (optional): If specified, the fragment will be created in this context,
+    // defaults to document
+    // keepScripts (optional): If true, will include scripts passed in the html string
+
+
+    jQuery.parseHTML = function (data, context, keepScripts) {
+      if (typeof data !== "string") {
+        return [];
+      }
+
+      if (typeof context === "boolean") {
+        keepScripts = context;
+        context = false;
+      }
+
+      var base, parsed, scripts;
+
+      if (!context) {
+        // Stop scripts or inline event handlers from being executed immediately
+        // by using document.implementation
+        if (support.createHTMLDocument) {
+          context = document$2.implementation.createHTMLDocument(""); // Set the base href for the created document
+          // so any parsed elements with URLs
+          // are based on the document's URL (gh-2965)
+
+          base = context.createElement("base");
+          base.href = document$2.location.href;
+          context.head.appendChild(base);
+        } else {
+          context = document$2;
+        }
+      }
+
+      parsed = rsingleTag.exec(data);
+      scripts = !keepScripts && []; // Single tag
+
+      if (parsed) {
+        return [context.createElement(parsed[1])];
+      }
+
+      parsed = buildFragment([data], context, scripts);
+
+      if (scripts && scripts.length) {
+        jQuery(scripts).remove();
+      }
+
+      return jQuery.merge([], parsed.childNodes);
+    };
+
+    jQuery.offset = {
+      setOffset: function (elem, options, i) {
+        var curPosition,
+            curLeft,
+            curCSSTop,
+            curTop,
+            curOffset,
+            curCSSLeft,
+            calculatePosition,
+            position = jQuery.css(elem, "position"),
+            curElem = jQuery(elem),
+            props = {}; // Set position first, in-case top/left are set even on static elem
+
+        if (position === "static") {
+          elem.style.position = "relative";
+        }
+
+        curOffset = curElem.offset();
+        curCSSTop = jQuery.css(elem, "top");
+        curCSSLeft = jQuery.css(elem, "left");
+        calculatePosition = (position === "absolute" || position === "fixed") && (curCSSTop + curCSSLeft).indexOf("auto") > -1; // Need to be able to calculate position if either
+        // top or left is auto and position is either absolute or fixed
+
+        if (calculatePosition) {
+          curPosition = curElem.position();
+          curTop = curPosition.top;
+          curLeft = curPosition.left;
+        } else {
+          curTop = parseFloat(curCSSTop) || 0;
+          curLeft = parseFloat(curCSSLeft) || 0;
+        }
+
+        if (isFunction(options)) {
+          // Use jQuery.extend here to allow modification of coordinates argument (gh-1848)
+          options = options.call(elem, i, jQuery.extend({}, curOffset));
+        }
+
+        if (options.top != null) {
+          props.top = options.top - curOffset.top + curTop;
+        }
+
+        if (options.left != null) {
+          props.left = options.left - curOffset.left + curLeft;
+        }
+
+        if ("using" in options) {
+          options.using.call(elem, props);
+        } else {
+          curElem.css(props);
+        }
+      }
+    };
+    jQuery.fn.extend({
+      // offset() relates an element's border box to the document origin
+      offset: function (options) {
+        // Preserve chaining for setter
+        if (arguments.length) {
+          return options === undefined ? this : this.each(function (i) {
+            jQuery.offset.setOffset(this, options, i);
+          });
+        }
+
+        var rect,
+            win,
+            elem = this[0];
+
+        if (!elem) {
+          return;
+        } // Return zeros for disconnected and hidden (display: none) elements (gh-2310)
+        // Support: IE <=11 only
+        // Running getBoundingClientRect on a
+        // disconnected node in IE throws an error
+
+
+        if (!elem.getClientRects().length) {
+          return {
+            top: 0,
+            left: 0
+          };
+        } // Get document-relative position by adding viewport scroll to viewport-relative gBCR
+
+
+        rect = elem.getBoundingClientRect();
+        win = elem.ownerDocument.defaultView;
+        return {
+          top: rect.top + win.pageYOffset,
+          left: rect.left + win.pageXOffset
+        };
+      },
+      // position() relates an element's margin box to its offset parent's padding box
+      // This corresponds to the behavior of CSS absolute positioning
+      position: function () {
+        if (!this[0]) {
+          return;
+        }
+
+        var offsetParent,
+            offset,
+            doc,
+            elem = this[0],
+            parentOffset = {
+          top: 0,
+          left: 0
+        }; // position:fixed elements are offset from the viewport, which itself always has zero offset
+
+        if (jQuery.css(elem, "position") === "fixed") {
+          // Assume position:fixed implies availability of getBoundingClientRect
+          offset = elem.getBoundingClientRect();
+        } else {
+          offset = this.offset(); // Account for the *real* offset parent, which can be the document or its root element
+          // when a statically positioned element is identified
+
+          doc = elem.ownerDocument;
+          offsetParent = elem.offsetParent || doc.documentElement;
+
+          while (offsetParent && (offsetParent === doc.body || offsetParent === doc.documentElement) && jQuery.css(offsetParent, "position") === "static") {
+            offsetParent = offsetParent.parentNode;
+          }
+
+          if (offsetParent && offsetParent !== elem && offsetParent.nodeType === 1) {
+            // Incorporate borders into its offset, since they are outside its content origin
+            parentOffset = jQuery(offsetParent).offset();
+            parentOffset.top += jQuery.css(offsetParent, "borderTopWidth", true);
+            parentOffset.left += jQuery.css(offsetParent, "borderLeftWidth", true);
+          }
+        } // Subtract parent offsets and element margins
+
+
+        return {
+          top: offset.top - parentOffset.top - jQuery.css(elem, "marginTop", true),
+          left: offset.left - parentOffset.left - jQuery.css(elem, "marginLeft", true)
+        };
+      },
+      // This method will return documentElement in the following cases:
+      // 1) For the element inside the iframe without offsetParent, this method will return
+      //    documentElement of the parent window
+      // 2) For the hidden or detached element
+      // 3) For body or html element, i.e. in case of the html node - it will return itself
+      //
+      // but those exceptions were never presented as a real life use-cases
+      // and might be considered as more preferable results.
+      //
+      // This logic, however, is not guaranteed and can change at any point in the future
+      offsetParent: function () {
+        return this.map(function () {
+          var offsetParent = this.offsetParent;
+
+          while (offsetParent && jQuery.css(offsetParent, "position") === "static") {
+            offsetParent = offsetParent.offsetParent;
+          }
+
+          return offsetParent || documentElement;
+        });
+      }
+    }); // Create scrollLeft and scrollTop methods
+
+    jQuery.each({
+      scrollLeft: "pageXOffset",
+      scrollTop: "pageYOffset"
+    }, function (method, prop) {
+      var top = "pageYOffset" === prop;
+
+      jQuery.fn[method] = function (val) {
+        return access(this, function (elem, method, val) {
+          // Coalesce documents and windows
+          var win;
+
+          if (isWindow(elem)) {
+            win = elem;
+          } else if (elem.nodeType === 9) {
+            win = elem.defaultView;
+          }
+
+          if (val === undefined) {
+            return win ? win[prop] : elem[method];
+          }
+
+          if (win) {
+            win.scrollTo(!top ? val : win.pageXOffset, top ? val : win.pageYOffset);
+          } else {
+            elem[method] = val;
+          }
+        }, method, val, arguments.length);
+      };
+    }); // Support: Safari <=7 - 9.1, Chrome <=37 - 49
+    // Add the top/left cssHooks using jQuery.fn.position
+    // Webkit bug: https://bugs.webkit.org/show_bug.cgi?id=29084
+    // Blink bug: https://bugs.chromium.org/p/chromium/issues/detail?id=589347
+    // getComputedStyle returns percent when specified for top/left/bottom/right;
+    // rather than make the css module depend on the offset module, just check for it here
+
+    jQuery.each(["top", "left"], function (i, prop) {
+      jQuery.cssHooks[prop] = addGetHookIf(support.pixelPosition, function (elem, computed) {
+        if (computed) {
+          computed = curCSS(elem, prop); // If curCSS returns percentage, fallback to offset
+
+          return rnumnonpx.test(computed) ? jQuery(elem).position()[prop] + "px" : computed;
+        }
+      });
+    }); // Create innerHeight, innerWidth, height, width, outerHeight and outerWidth methods
+
+    jQuery.each({
+      Height: "height",
+      Width: "width"
+    }, function (name, type) {
+      jQuery.each({
+        padding: "inner" + name,
+        content: type,
+        "": "outer" + name
+      }, function (defaultExtra, funcName) {
+        // Margin is only for outerHeight, outerWidth
+        jQuery.fn[funcName] = function (margin, value) {
+          var chainable = arguments.length && (defaultExtra || typeof margin !== "boolean"),
+              extra = defaultExtra || (margin === true || value === true ? "margin" : "border");
+          return access(this, function (elem, type, value) {
+            var doc;
+
+            if (isWindow(elem)) {
+              // $( window ).outerWidth/Height return w/h including scrollbars (gh-1729)
+              return funcName.indexOf("outer") === 0 ? elem["inner" + name] : elem.document.documentElement["client" + name];
+            } // Get document width or height
+
+
+            if (elem.nodeType === 9) {
+              doc = elem.documentElement; // Either scroll[Width/Height] or offset[Width/Height] or client[Width/Height],
+              // whichever is greatest
+
+              return Math.max(elem.body["scroll" + name], doc["scroll" + name], elem.body["offset" + name], doc["offset" + name], doc["client" + name]);
+            }
+
+            return value === undefined ? // Get width or height on the element, requesting but not forcing parseFloat
+            jQuery.css(elem, type, extra) : // Set width or height on the element
+            jQuery.style(elem, type, value, extra);
+          }, type, chainable ? margin : undefined, chainable);
+        };
+      });
+    });
+    jQuery.each(("blur focus focusin focusout resize scroll click dblclick " + "mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave " + "change select submit keydown keypress keyup contextmenu").split(" "), function (i, name) {
+      // Handle event binding
+      jQuery.fn[name] = function (data, fn) {
+        return arguments.length > 0 ? this.on(name, null, data, fn) : this.trigger(name);
+      };
+    });
+    jQuery.fn.extend({
+      hover: function (fnOver, fnOut) {
+        return this.mouseenter(fnOver).mouseleave(fnOut || fnOver);
+      }
+    });
+    jQuery.fn.extend({
+      bind: function (types, data, fn) {
+        return this.on(types, null, data, fn);
+      },
+      unbind: function (types, fn) {
+        return this.off(types, null, fn);
+      },
+      delegate: function (selector, types, data, fn) {
+        return this.on(types, selector, data, fn);
+      },
+      undelegate: function (selector, types, fn) {
+        // ( namespace ) or ( selector, types [, fn] )
+        return arguments.length === 1 ? this.off(selector, "**") : this.off(types, selector || "**", fn);
+      }
+    }); // Bind a function to a context, optionally partially applying any
+    // arguments.
+    // jQuery.proxy is deprecated to promote standards (specifically Function#bind)
+    // However, it is not slated for removal any time soon
+
+    jQuery.proxy = function (fn, context) {
+      var tmp, args, proxy;
+
+      if (typeof context === "string") {
+        tmp = fn[context];
+        context = fn;
+        fn = tmp;
+      } // Quick check to determine if target is callable, in the spec
+      // this throws a TypeError, but we will just return undefined.
+
+
+      if (!isFunction(fn)) {
+        return undefined;
+      } // Simulated bind
+
+
+      args = slice.call(arguments, 2);
+
+      proxy = function () {
+        return fn.apply(context || this, args.concat(slice.call(arguments)));
+      }; // Set the guid of unique handler to the same of original handler, so it can be removed
+
+
+      proxy.guid = fn.guid = fn.guid || jQuery.guid++;
+      return proxy;
+    };
+
+    jQuery.holdReady = function (hold) {
+      if (hold) {
+        jQuery.readyWait++;
+      } else {
+        jQuery.ready(true);
+      }
+    };
+
+    jQuery.isArray = Array.isArray;
+    jQuery.parseJSON = JSON.parse;
+    jQuery.nodeName = nodeName;
+    jQuery.isFunction = isFunction;
+    jQuery.isWindow = isWindow;
+    jQuery.camelCase = camelCase;
+    jQuery.type = toType;
+    jQuery.now = Date.now;
+
+    jQuery.isNumeric = function (obj) {
+      // As of jQuery 3.0, isNumeric is limited to
+      // strings and numbers (primitives or objects)
+      // that can be coerced to finite numbers (gh-2662)
+      var type = jQuery.type(obj);
+      return (type === "number" || type === "string") && // parseFloat NaNs numeric-cast false positives ("")
+      // ...but misinterprets leading-number strings, particularly hex literals ("0x...")
+      // subtraction forces infinities to NaN
+      !isNaN(obj - parseFloat(obj));
+    };
+
+    const $ = jQuery;
+
+    function div$1(options) {
+      return create$1("div", options);
+    }
+
+    function create$1(tag, options) {
+      const elem = document.createElement(tag);
+
+      if (options) {
+        if (options.class) {
+          elem.classList.add(options.class);
+        }
+
+        if (options.id) {
+          elem.id = options.id;
+        }
+
+        if (options.style) {
+          applyStyle$1(elem, options.style);
+        }
+      }
+
+      return elem;
+    }
+
+    function hide$1(elem) {
+      const cssStyle = getComputedStyle(elem);
+
+      if (cssStyle.display !== "none") {
+        elem._initialDisplay = cssStyle.display;
+      }
+
+      elem.style.display = "none";
+    }
+
+    function offset$1(elem) {
+      // Return zeros for disconnected and hidden (display: none) elements (gh-2310)
+      // Support: IE <=11 only
+      // Running getBoundingClientRect on a
+      // disconnected node in IE throws an error
+      if (!elem.getClientRects().length) {
+        return {
+          top: 0,
+          left: 0
+        };
+      } // Get document-relative position by adding viewport scroll to viewport-relative gBCR
+
+
+      const rect = elem.getBoundingClientRect();
+      const win = elem.ownerDocument.defaultView;
+      return {
+        top: rect.top + win.pageYOffset,
+        left: rect.left + win.pageXOffset
+      };
+    }
+
+    function pageCoordinates$1(e) {
+      if (e.type.startsWith("touch")) {
+        const touch = e.touches[0];
+        return {
+          x: touch.pageX,
+          y: touch.pageY
+        };
+      } else {
+        return {
+          x: e.pageX,
+          y: e.pageY
+        };
+      }
+    }
+
+    const relativeDOMBBox = (parentElement, childElement) => {
+      const {
+        x: x_p,
+        y: y_p,
+        width: width_p,
+        height: height_p
+      } = parentElement.getBoundingClientRect();
+      const {
+        x: x_c,
+        y: y_c,
+        width: width_c,
+        height: height_c
+      } = childElement.getBoundingClientRect();
+      return {
+        x: x_c - x_p,
+        y: y_c - y_p,
+        width: width_c,
+        height: height_c
+      };
+    };
+
+    function applyStyle$1(elem, style) {
+      for (let key of Object.keys(style)) {
+        elem.style[key] = style[key];
+      }
+    }
+
+    function guid() {
+      return ("0000" + (Math.random() * Math.pow(36, 4) << 0).toString(36)).slice(-4);
+    }
+
+    let getMouseXY$1 = (domElement, {
+      clientX,
+      clientY
+    }) => {
+      // DOMRect object with eight properties: left, top, right, bottom, x, y, width, height
+      const {
+        left,
+        top,
+        width,
+        height
+      } = domElement.getBoundingClientRect();
+      const x = clientX - left;
+      const y = clientY - top;
+      return {
+        x,
+        y,
+        xNormalized: x / width,
+        yNormalized: y / height,
+        width,
+        height
+      };
+    };
+    /**
+     * Translate the mouse coordinates for the event to the coordinates for the given target element
+     * @param event
+     * @param domElement
+     * @returns {{x: number, y: number}}
+     */
+
+
+    function translateMouseCoordinates$1(event, domElement) {
+      const {
+        clientX,
+        clientY
+      } = event;
+      return getMouseXY$1(domElement, {
+        clientX,
+        clientY
+      });
+    }
+
+    function createIcon$2(name, color) {
+      return iconMarkup$1(name, color);
+    }
+
+    function iconMarkup$1(name, color) {
+      color = color || "currentColor";
+      let icon = icons$1[name];
+
+      if (!icon) {
+        console.error(`No icon named: ${name}`);
+        icon = icons$1["question"];
+      }
+
+      const svg = document.createElementNS("http://www.w3.org/2000/svg", "svg");
+      svg.setAttributeNS(null, 'viewBox', '0 0 ' + icon[0] + ' ' + icon[1]);
+      const path = document.createElementNS("http://www.w3.org/2000/svg", "path");
+      path.setAttributeNS(null, 'fill', color);
+      path.setAttributeNS(null, 'd', icon[4]);
+      svg.appendChild(path);
+      return svg;
+    }
+
+    const icons$1 = {
+      "check": [512, 512, [], "f00c", "M173.898 439.404l-166.4-166.4c-9.997-9.997-9.997-26.206 0-36.204l36.203-36.204c9.997-9.998 26.207-9.998 36.204 0L192 312.69 432.095 72.596c9.997-9.997 26.207-9.997 36.204 0l36.203 36.204c9.997 9.997 9.997 26.206 0 36.204l-294.4 294.401c-9.998 9.997-26.207 9.997-36.204-.001z"],
+      "cog": [512, 512, [], "f013", "M444.788 291.1l42.616 24.599c4.867 2.809 7.126 8.618 5.459 13.985-11.07 35.642-29.97 67.842-54.689 94.586a12.016 12.016 0 0 1-14.832 2.254l-42.584-24.595a191.577 191.577 0 0 1-60.759 35.13v49.182a12.01 12.01 0 0 1-9.377 11.718c-34.956 7.85-72.499 8.256-109.219.007-5.49-1.233-9.403-6.096-9.403-11.723v-49.184a191.555 191.555 0 0 1-60.759-35.13l-42.584 24.595a12.016 12.016 0 0 1-14.832-2.254c-24.718-26.744-43.619-58.944-54.689-94.586-1.667-5.366.592-11.175 5.459-13.985L67.212 291.1a193.48 193.48 0 0 1 0-70.199l-42.616-24.599c-4.867-2.809-7.126-8.618-5.459-13.985 11.07-35.642 29.97-67.842 54.689-94.586a12.016 12.016 0 0 1 14.832-2.254l42.584 24.595a191.577 191.577 0 0 1 60.759-35.13V25.759a12.01 12.01 0 0 1 9.377-11.718c34.956-7.85 72.499-8.256 109.219-.007 5.49 1.233 9.403 6.096 9.403 11.723v49.184a191.555 191.555 0 0 1 60.759 35.13l42.584-24.595a12.016 12.016 0 0 1 14.832 2.254c24.718 26.744 43.619 58.944 54.689 94.586 1.667 5.366-.592 11.175-5.459 13.985L444.788 220.9a193.485 193.485 0 0 1 0 70.2zM336 256c0-44.112-35.888-80-80-80s-80 35.888-80 80 35.888 80 80 80 80-35.888 80-80z"],
+      "exclamation": [192, 512, [], "f12a", "M176 432c0 44.112-35.888 80-80 80s-80-35.888-80-80 35.888-80 80-80 80 35.888 80 80zM25.26 25.199l13.6 272C39.499 309.972 50.041 320 62.83 320h66.34c12.789 0 23.331-10.028 23.97-22.801l13.6-272C167.425 11.49 156.496 0 142.77 0H49.23C35.504 0 24.575 11.49 25.26 25.199z"],
+      "exclamation-circle": [512, 512, [], "f06a", "M504 256c0 136.997-111.043 248-248 248S8 392.997 8 256C8 119.083 119.043 8 256 8s248 111.083 248 248zm-248 50c-25.405 0-46 20.595-46 46s20.595 46 46 46 46-20.595 46-46-20.595-46-46-46zm-43.673-165.346l7.418 136c.347 6.364 5.609 11.346 11.982 11.346h48.546c6.373 0 11.635-4.982 11.982-11.346l7.418-136c.375-6.874-5.098-12.654-11.982-12.654h-63.383c-6.884 0-12.356 5.78-11.981 12.654z"],
+      "exclamation-triangle": [576, 512, [], "f071", "M569.517 440.013C587.975 472.007 564.806 512 527.94 512H48.054c-36.937 0-59.999-40.055-41.577-71.987L246.423 23.985c18.467-32.009 64.72-31.951 83.154 0l239.94 416.028zM288 354c-25.405 0-46 20.595-46 46s20.595 46 46 46 46-20.595 46-46-20.595-46-46-46zm-43.673-165.346l7.418 136c.347 6.364 5.609 11.346 11.982 11.346h48.546c6.373 0 11.635-4.982 11.982-11.346l7.418-136c.375-6.874-5.098-12.654-11.982-12.654h-63.383c-6.884 0-12.356 5.78-11.981 12.654z"],
+      "minus": [448, 512, [], "f068", "M424 318.2c13.3 0 24-10.7 24-24v-76.4c0-13.3-10.7-24-24-24H24c-13.3 0-24 10.7-24 24v76.4c0 13.3 10.7 24 24 24h400z"],
+      "minus-circle": [512, 512, [], "f056", "M256 8C119 8 8 119 8 256s111 248 248 248 248-111 248-248S393 8 256 8zM124 296c-6.6 0-12-5.4-12-12v-56c0-6.6 5.4-12 12-12h264c6.6 0 12 5.4 12 12v56c0 6.6-5.4 12-12 12H124z"],
+      "minus-square": [448, 512, [], "f146", "M400 32H48C21.5 32 0 53.5 0 80v352c0 26.5 21.5 48 48 48h352c26.5 0 48-21.5 48-48V80c0-26.5-21.5-48-48-48zM92 296c-6.6 0-12-5.4-12-12v-56c0-6.6 5.4-12 12-12h264c6.6 0 12 5.4 12 12v56c0 6.6-5.4 12-12 12H92z"],
+      "plus": [448, 512, [], "f067", "M448 294.2v-76.4c0-13.3-10.7-24-24-24H286.2V56c0-13.3-10.7-24-24-24h-76.4c-13.3 0-24 10.7-24 24v137.8H24c-13.3 0-24 10.7-24 24v76.4c0 13.3 10.7 24 24 24h137.8V456c0 13.3 10.7 24 24 24h76.4c13.3 0 24-10.7 24-24V318.2H424c13.3 0 24-10.7 24-24z"],
+      "plus-circle": [512, 512, [], "f055", "M256 8C119 8 8 119 8 256s111 248 248 248 248-111 248-248S393 8 256 8zm144 276c0 6.6-5.4 12-12 12h-92v92c0 6.6-5.4 12-12 12h-56c-6.6 0-12-5.4-12-12v-92h-92c-6.6 0-12-5.4-12-12v-56c0-6.6 5.4-12 12-12h92v-92c0-6.6 5.4-12 12-12h56c6.6 0 12 5.4 12 12v92h92c6.6 0 12 5.4 12 12v56z"],
+      "plus-square": [448, 512, [], "f0fe", "M400 32H48C21.5 32 0 53.5 0 80v352c0 26.5 21.5 48 48 48h352c26.5 0 48-21.5 48-48V80c0-26.5-21.5-48-48-48zm-32 252c0 6.6-5.4 12-12 12h-92v92c0 6.6-5.4 12-12 12h-56c-6.6 0-12-5.4-12-12v-92H92c-6.6 0-12-5.4-12-12v-56c0-6.6 5.4-12 12-12h92v-92c0-6.6 5.4-12 12-12h56c6.6 0 12 5.4 12 12v92h92c6.6 0 12 5.4 12 12v56z"],
+      "question": [384, 512, [], "f128", "M202.021 0C122.202 0 70.503 32.703 29.914 91.026c-7.363 10.58-5.093 25.086 5.178 32.874l43.138 32.709c10.373 7.865 25.132 6.026 33.253-4.148 25.049-31.381 43.63-49.449 82.757-49.449 30.764 0 68.816 19.799 68.816 49.631 0 22.552-18.617 34.134-48.993 51.164-35.423 19.86-82.299 44.576-82.299 106.405V320c0 13.255 10.745 24 24 24h72.471c13.255 0 24-10.745 24-24v-5.773c0-42.86 125.268-44.645 125.268-160.627C377.504 66.256 286.902 0 202.021 0zM192 373.459c-38.196 0-69.271 31.075-69.271 69.271 0 38.195 31.075 69.27 69.271 69.27s69.271-31.075 69.271-69.271-31.075-69.27-69.271-69.27z"],
+      "save": [448, 512, [], "f0c7", "M433.941 129.941l-83.882-83.882A48 48 0 0 0 316.118 32H48C21.49 32 0 53.49 0 80v352c0 26.51 21.49 48 48 48h352c26.51 0 48-21.49 48-48V163.882a48 48 0 0 0-14.059-33.941zM224 416c-35.346 0-64-28.654-64-64 0-35.346 28.654-64 64-64s64 28.654 64 64c0 35.346-28.654 64-64 64zm96-304.52V212c0 6.627-5.373 12-12 12H76c-6.627 0-12-5.373-12-12V108c0-6.627 5.373-12 12-12h228.52c3.183 0 6.235 1.264 8.485 3.515l3.48 3.48A11.996 11.996 0 0 1 320 111.48z"],
+      "search": [512, 512, [], "f002", "M505 442.7L405.3 343c-4.5-4.5-10.6-7-17-7H372c27.6-35.3 44-79.7 44-128C416 93.1 322.9 0 208 0S0 93.1 0 208s93.1 208 208 208c48.3 0 92.7-16.4 128-44v16.3c0 6.4 2.5 12.5 7 17l99.7 99.7c9.4 9.4 24.6 9.4 33.9 0l28.3-28.3c9.4-9.4 9.4-24.6.1-34zM208 336c-70.7 0-128-57.2-128-128 0-70.7 57.2-128 128-128 70.7 0 128 57.2 128 128 0 70.7-57.2 128-128 128z"],
+      "share": [512, 512, [], "f064", "M503.691 189.836L327.687 37.851C312.281 24.546 288 35.347 288 56.015v80.053C127.371 137.907 0 170.1 0 322.326c0 61.441 39.581 122.309 83.333 154.132 13.653 9.931 33.111-2.533 28.077-18.631C66.066 312.814 132.917 274.316 288 272.085V360c0 20.7 24.3 31.453 39.687 18.164l176.004-152c11.071-9.562 11.086-26.753 0-36.328z"],
+      "spinner": [512, 512, [], "f110", "M304 48c0 26.51-21.49 48-48 48s-48-21.49-48-48 21.49-48 48-48 48 21.49 48 48zm-48 368c-26.51 0-48 21.49-48 48s21.49 48 48 48 48-21.49 48-48-21.49-48-48-48zm208-208c-26.51 0-48 21.49-48 48s21.49 48 48 48 48-21.49 48-48-21.49-48-48-48zM96 256c0-26.51-21.49-48-48-48S0 229.49 0 256s21.49 48 48 48 48-21.49 48-48zm12.922 99.078c-26.51 0-48 21.49-48 48s21.49 48 48 48 48-21.49 48-48c0-26.509-21.491-48-48-48zm294.156 0c-26.51 0-48 21.49-48 48s21.49 48 48 48 48-21.49 48-48c0-26.509-21.49-48-48-48zM108.922 60.922c-26.51 0-48 21.49-48 48s21.49 48 48 48 48-21.49 48-48-21.491-48-48-48z"],
+      "square": [448, 512, [], "f0c8", "M400 32H48C21.5 32 0 53.5 0 80v352c0 26.5 21.5 48 48 48h352c26.5 0 48-21.5 48-48V80c0-26.5-21.5-48-48-48z"],
+      "square-full": [512, 512, [], "f45c", "M512 512H0V0h512v512z"],
+      "times": [384, 512, [], "f00d", "M323.1 441l53.9-53.9c9.4-9.4 9.4-24.5 0-33.9L279.8 256l97.2-97.2c9.4-9.4 9.4-24.5 0-33.9L323.1 71c-9.4-9.4-24.5-9.4-33.9 0L192 168.2 94.8 71c-9.4-9.4-24.5-9.4-33.9 0L7 124.9c-9.4 9.4-9.4 24.5 0 33.9l97.2 97.2L7 353.2c-9.4 9.4-9.4 24.5 0 33.9L60.9 441c9.4 9.4 24.5 9.4 33.9 0l97.2-97.2 97.2 97.2c9.3 9.3 24.5 9.3 33.9 0z"],
+      "times-circle": [512, 512, [], "f057", "M256 8C119 8 8 119 8 256s111 248 248 248 248-111 248-248S393 8 256 8zm121.6 313.1c4.7 4.7 4.7 12.3 0 17L338 377.6c-4.7 4.7-12.3 4.7-17 0L256 312l-65.1 65.6c-4.7 4.7-12.3 4.7-17 0L134.4 338c-4.7-4.7-4.7-12.3 0-17l65.6-65-65.6-65.1c-4.7-4.7-4.7-12.3 0-17l39.6-39.6c4.7-4.7 12.3-4.7 17 0l65 65.7 65.1-65.6c4.7-4.7 12.3-4.7 17 0l39.6 39.6c4.7 4.7 4.7 12.3 0 17L312 256l65.6 65.1z"],
+      "wrench": [512, 512, [], "f0ad", "M481.156 200c9.3 0 15.12 10.155 10.325 18.124C466.295 259.992 420.419 288 368 288c-79.222 0-143.501-63.974-143.997-143.079C223.505 65.469 288.548-.001 368.002 0c52.362.001 98.196 27.949 123.4 69.743C496.24 77.766 490.523 88 481.154 88H376l-40 56 40 56h105.156zm-171.649 93.003L109.255 493.255c-24.994 24.993-65.515 24.994-90.51 0-24.993-24.994-24.993-65.516 0-90.51L218.991 202.5c16.16 41.197 49.303 74.335 90.516 90.503zM104 432c0-13.255-10.745-24-24-24s-24 10.745-24 24 10.745 24 24 24 24-10.745 24-24z"]
+    };
+
+    function attachDialogCloseHandlerWithParent$1(parent, closeHandler) {
+      var container = document.createElement("div");
+      parent.appendChild(container);
+      container.appendChild(createIcon$2("times"));
+      container.addEventListener('click', function (e) {
+        e.preventDefault();
+        e.stopPropagation();
+        closeHandler();
+      });
+    }
+
+    /**
+     * @fileoverview Zlib namespace. Zlib ã®ä»•æ§˜ã«æº–æ‹ ã—ãŸåœ§ç¸®ã¯ Zlib.Deflate で実装
+     * されている. これは Inflate との共存を考慮している為.
+     */
+    const ZLIB_STREAM_RAW_INFLATE_BUFFER_SIZE$1 = 65000;
+    var Zlib$1 = {
+      Huffman: {},
+      Util: {},
+      CRC32: {}
+    };
+    /**
+     * Compression Method
+     * @enum {number}
+     */
+
+    Zlib$1.CompressionMethod = {
+      DEFLATE: 8,
+      RESERVED: 15
+    };
+    /**
+     * @param {Object=} opt_params options.
+     * @constructor
+     */
+
+    Zlib$1.Zip = function (opt_params) {
+      opt_params = opt_params || {};
+      /** @type {Array.<{
+       *   buffer: !(Array.<number>|Uint8Array),
+       *   option: Object,
+       *   compressed: boolean,
+       *   encrypted: boolean,
+       *   size: number,
+       *   crc32: number
+       * }>} */
+
+      this.files = [];
+      /** @type {(Array.<number>|Uint8Array)} */
+
+      this.comment = opt_params['comment'];
+      /** @type {(Array.<number>|Uint8Array)} */
+
+      this.password;
+    };
+    /**
+     * @enum {number}
+     */
+
+
+    Zlib$1.Zip.CompressionMethod = {
+      STORE: 0,
+      DEFLATE: 8
+    };
+    /**
+     * @enum {number}
+     */
+
+    Zlib$1.Zip.OperatingSystem = {
+      MSDOS: 0,
+      UNIX: 3,
+      MACINTOSH: 7
+    };
+    /**
+     * @enum {number}
+     */
+
+    Zlib$1.Zip.Flags = {
+      ENCRYPT: 0x0001,
+      DESCRIPTOR: 0x0008,
+      UTF8: 0x0800
+    };
+    /**
+     * @type {Array.<number>}
+     * @const
+     */
+
+    Zlib$1.Zip.FileHeaderSignature = [0x50, 0x4b, 0x01, 0x02];
+    /**
+     * @type {Array.<number>}
+     * @const
+     */
+
+    Zlib$1.Zip.LocalFileHeaderSignature = [0x50, 0x4b, 0x03, 0x04];
+    /**
+     * @type {Array.<number>}
+     * @const
+     */
+
+    Zlib$1.Zip.CentralDirectorySignature = [0x50, 0x4b, 0x05, 0x06];
+    /**
+     * @param {Array.<number>|Uint8Array} input
+     * @param {Object=} opt_params options.
+     */
+
+    Zlib$1.Zip.prototype.addFile = function (input, opt_params) {
+      opt_params = opt_params || {};
+      /** @type {string} */
+
+      opt_params['filename'];
+      /** @type {boolean} */
+
+      var compressed;
+      /** @type {number} */
+
+      var size = input.length;
+      /** @type {number} */
+
+      var crc32 = 0;
+
+      if (input instanceof Array) {
+        input = new Uint8Array(input);
+      } // default
+
+
+      if (typeof opt_params['compressionMethod'] !== 'number') {
+        opt_params['compressionMethod'] = Zlib$1.Zip.CompressionMethod.DEFLATE;
+      } // ãã®å ´ã§åœ§ç¸®ã™ã‚‹å ´åˆ
+
+
+      if (opt_params['compress']) {
+        switch (opt_params['compressionMethod']) {
+          case Zlib$1.Zip.CompressionMethod.STORE:
+            break;
+
+          case Zlib$1.Zip.CompressionMethod.DEFLATE:
+            crc32 = Zlib$1.CRC32.calc(input);
+            input = this.deflateWithOption(input, opt_params);
+            compressed = true;
+            break;
+
+          default:
+            throw new Error('unknown compression method:' + opt_params['compressionMethod']);
+        }
+      }
+
+      this.files.push({
+        buffer: input,
+        option: opt_params,
+        compressed: compressed,
+        encrypted: false,
+        size: size,
+        crc32: crc32
+      });
+    };
+    /**
+     * @param {(Array.<number>|Uint8Array)} password
+     */
+
+
+    Zlib$1.Zip.prototype.setPassword = function (password) {
+      this.password = password;
+    };
+
+    Zlib$1.Zip.prototype.compress = function () {
+      /** @type {Array.<{
+       *   buffer: !(Array.<number>|Uint8Array),
+       *   option: Object,
+       *   compressed: boolean,
+       *   encrypted: boolean,
+       *   size: number,
+       *   crc32: number
+       * }>} */
+      var files = this.files;
+      /** @type {{
+       *   buffer: !(Array.<number>|Uint8Array),
+       *   option: Object,
+       *   compressed: boolean,
+       *   encrypted: boolean,
+       *   size: number,
+       *   crc32: number
+       * }} */
+
+      var file;
+      /** @type {!(Array.<number>|Uint8Array)} */
+
+      var output;
+      /** @type {number} */
+
+      var op1;
+      /** @type {number} */
+
+      var op2;
+      /** @type {number} */
+
+      var op3;
+      /** @type {number} */
+
+      var localFileSize = 0;
+      /** @type {number} */
+
+      var centralDirectorySize = 0;
+      /** @type {number} */
+
+      var endOfCentralDirectorySize;
+      /** @type {number} */
+
+      var offset;
+      /** @type {number} */
+
+      var needVersion;
+      /** @type {number} */
+
+      var flags;
+      /** @type {Zlib.Zip.CompressionMethod} */
+
+      var compressionMethod;
+      /** @type {Date} */
+
+      var date;
+      /** @type {number} */
+
+      var crc32;
+      /** @type {number} */
+
+      var size;
+      /** @type {number} */
+
+      var plainSize;
+      /** @type {number} */
+
+      var filenameLength;
+      /** @type {number} */
+
+      var extraFieldLength;
+      /** @type {number} */
+
+      var commentLength;
+      /** @type {(Array.<number>|Uint8Array)} */
+
+      var filename;
+      /** @type {(Array.<number>|Uint8Array)} */
+
+      var extraField;
+      /** @type {(Array.<number>|Uint8Array)} */
+
+      var comment;
+      /** @type {(Array.<number>|Uint8Array)} */
+
+      var buffer;
+      /** @type {*} */
+
+      var tmp;
+      /** @type {Array.<number>|Uint32Array|Object} */
+
+      var key;
+      /** @type {number} */
+
+      var i;
+      /** @type {number} */
+
+      var il;
+      /** @type {number} */
+
+      var j;
+      /** @type {number} */
+
+      var jl; // ファイルの圧縮
+
+      for (i = 0, il = files.length; i < il; ++i) {
+        file = files[i];
+        filenameLength = file.option['filename'] ? file.option['filename'].length : 0;
+        extraFieldLength = file.option['extraField'] ? file.option['extraField'].length : 0;
+        commentLength = file.option['comment'] ? file.option['comment'].length : 0; // 圧縮されていなかったら圧縮
+
+        if (!file.compressed) {
+          // 圧縮前に CRC32 の計算をしておく
+          file.crc32 = Zlib$1.CRC32.calc(file.buffer);
+
+          switch (file.option['compressionMethod']) {
+            case Zlib$1.Zip.CompressionMethod.STORE:
+              break;
+
+            case Zlib$1.Zip.CompressionMethod.DEFLATE:
+              file.buffer = this.deflateWithOption(file.buffer, file.option);
+              file.compressed = true;
+              break;
+
+            default:
+              throw new Error('unknown compression method:' + file.option['compressionMethod']);
+          }
+        } // encryption
+
+
+        if (file.option['password'] !== void 0 || this.password !== void 0) {
+          // init encryption
+          key = this.createEncryptionKey(file.option['password'] || this.password); // add header
+
+          buffer = file.buffer;
+
+          {
+            tmp = new Uint8Array(buffer.length + 12);
+            tmp.set(buffer, 12);
+            buffer = tmp;
+          }
+
+          for (j = 0; j < 12; ++j) {
+            buffer[j] = this.encode(key, i === 11 ? file.crc32 & 0xff : Math.random() * 256 | 0);
+          } // data encryption
+
+
+          for (jl = buffer.length; j < jl; ++j) {
+            buffer[j] = this.encode(key, buffer[j]);
+          }
+
+          file.buffer = buffer;
+        } // 必要バッファサイズの計算
+
+
+        localFileSize += // local file header
+        30 + filenameLength + // file data
+        file.buffer.length;
+        centralDirectorySize += // file header
+        46 + filenameLength + commentLength;
+      } // end of central directory
+
+
+      endOfCentralDirectorySize = 22 + (this.comment ? this.comment.length : 0);
+      output = new (Uint8Array )(localFileSize + centralDirectorySize + endOfCentralDirectorySize);
+      op1 = 0;
+      op2 = localFileSize;
+      op3 = op2 + centralDirectorySize; // ファイルの圧縮
+
+      for (i = 0, il = files.length; i < il; ++i) {
+        file = files[i];
+        filenameLength = file.option['filename'] ? file.option['filename'].length : 0;
+        extraFieldLength = 0; // TODO
+
+        commentLength = file.option['comment'] ? file.option['comment'].length : 0; //-------------------------------------------------------------------------
+        // local file header & file header
+        //-------------------------------------------------------------------------
+
+        offset = op1; // signature
+        // local file header
+
+        output[op1++] = Zlib$1.Zip.LocalFileHeaderSignature[0];
+        output[op1++] = Zlib$1.Zip.LocalFileHeaderSignature[1];
+        output[op1++] = Zlib$1.Zip.LocalFileHeaderSignature[2];
+        output[op1++] = Zlib$1.Zip.LocalFileHeaderSignature[3]; // file header
+
+        output[op2++] = Zlib$1.Zip.FileHeaderSignature[0];
+        output[op2++] = Zlib$1.Zip.FileHeaderSignature[1];
+        output[op2++] = Zlib$1.Zip.FileHeaderSignature[2];
+        output[op2++] = Zlib$1.Zip.FileHeaderSignature[3]; // compressor info
+
+        needVersion = 20;
+        output[op2++] = needVersion & 0xff;
+        output[op2++] =
+        /** @type {Zlib.Zip.OperatingSystem} */
+        file.option['os'] || Zlib$1.Zip.OperatingSystem.MSDOS; // need version
+
+        output[op1++] = output[op2++] = needVersion & 0xff;
+        output[op1++] = output[op2++] = needVersion >> 8 & 0xff; // general purpose bit flag
+
+        flags = 0;
+
+        if (file.option['password'] || this.password) {
+          flags |= Zlib$1.Zip.Flags.ENCRYPT;
+        }
+
+        output[op1++] = output[op2++] = flags & 0xff;
+        output[op1++] = output[op2++] = flags >> 8 & 0xff; // compression method
+
+        compressionMethod = file.option['compressionMethod'];
+        output[op1++] = output[op2++] = compressionMethod & 0xff;
+        output[op1++] = output[op2++] = compressionMethod >> 8 & 0xff; // date
+
+        date =
+        /** @type {(Date|undefined)} */
+        file.option['date'] || new Date();
+        output[op1++] = output[op2++] = (date.getMinutes() & 0x7) << 5 | (date.getSeconds() / 2 | 0);
+        output[op1++] = output[op2++] = date.getHours() << 3 | date.getMinutes() >> 3; //
+
+        output[op1++] = output[op2++] = (date.getMonth() + 1 & 0x7) << 5 | date.getDate();
+        output[op1++] = output[op2++] = (date.getFullYear() - 1980 & 0x7f) << 1 | date.getMonth() + 1 >> 3; // CRC-32
+
+        crc32 = file.crc32;
+        output[op1++] = output[op2++] = crc32 & 0xff;
+        output[op1++] = output[op2++] = crc32 >> 8 & 0xff;
+        output[op1++] = output[op2++] = crc32 >> 16 & 0xff;
+        output[op1++] = output[op2++] = crc32 >> 24 & 0xff; // compressed size
+
+        size = file.buffer.length;
+        output[op1++] = output[op2++] = size & 0xff;
+        output[op1++] = output[op2++] = size >> 8 & 0xff;
+        output[op1++] = output[op2++] = size >> 16 & 0xff;
+        output[op1++] = output[op2++] = size >> 24 & 0xff; // uncompressed size
+
+        plainSize = file.size;
+        output[op1++] = output[op2++] = plainSize & 0xff;
+        output[op1++] = output[op2++] = plainSize >> 8 & 0xff;
+        output[op1++] = output[op2++] = plainSize >> 16 & 0xff;
+        output[op1++] = output[op2++] = plainSize >> 24 & 0xff; // filename length
+
+        output[op1++] = output[op2++] = filenameLength & 0xff;
+        output[op1++] = output[op2++] = filenameLength >> 8 & 0xff; // extra field length
+
+        output[op1++] = output[op2++] = extraFieldLength & 0xff;
+        output[op1++] = output[op2++] = extraFieldLength >> 8 & 0xff; // file comment length
+
+        output[op2++] = commentLength & 0xff;
+        output[op2++] = commentLength >> 8 & 0xff; // disk number start
+
+        output[op2++] = 0;
+        output[op2++] = 0; // internal file attributes
+
+        output[op2++] = 0;
+        output[op2++] = 0; // external file attributes
+
+        output[op2++] = 0;
+        output[op2++] = 0;
+        output[op2++] = 0;
+        output[op2++] = 0; // relative offset of local header
+
+        output[op2++] = offset & 0xff;
+        output[op2++] = offset >> 8 & 0xff;
+        output[op2++] = offset >> 16 & 0xff;
+        output[op2++] = offset >> 24 & 0xff; // filename
+
+        filename = file.option['filename'];
+
+        if (filename) {
+          {
+            output.set(filename, op1);
+            output.set(filename, op2);
+            op1 += filenameLength;
+            op2 += filenameLength;
+          }
+        } // extra field
+
+
+        extraField = file.option['extraField'];
+
+        if (extraField) {
+          {
+            output.set(extraField, op1);
+            output.set(extraField, op2);
+            op1 += extraFieldLength;
+            op2 += extraFieldLength;
+          }
+        } // comment
+
+
+        comment = file.option['comment'];
+
+        if (comment) {
+          {
+            output.set(comment, op2);
+            op2 += commentLength;
+          }
+        } //-------------------------------------------------------------------------
+        // file data
+        //-------------------------------------------------------------------------
+
+
+        {
+          output.set(file.buffer, op1);
+          op1 += file.buffer.length;
+        }
+      } //-------------------------------------------------------------------------
+      // end of central directory
+      //-------------------------------------------------------------------------
+      // signature
+
+
+      output[op3++] = Zlib$1.Zip.CentralDirectorySignature[0];
+      output[op3++] = Zlib$1.Zip.CentralDirectorySignature[1];
+      output[op3++] = Zlib$1.Zip.CentralDirectorySignature[2];
+      output[op3++] = Zlib$1.Zip.CentralDirectorySignature[3]; // number of this disk
+
+      output[op3++] = 0;
+      output[op3++] = 0; // number of the disk with the start of the central directory
+
+      output[op3++] = 0;
+      output[op3++] = 0; // total number of entries in the central directory on this disk
+
+      output[op3++] = il & 0xff;
+      output[op3++] = il >> 8 & 0xff; // total number of entries in the central directory
+
+      output[op3++] = il & 0xff;
+      output[op3++] = il >> 8 & 0xff; // size of the central directory
+
+      output[op3++] = centralDirectorySize & 0xff;
+      output[op3++] = centralDirectorySize >> 8 & 0xff;
+      output[op3++] = centralDirectorySize >> 16 & 0xff;
+      output[op3++] = centralDirectorySize >> 24 & 0xff; // offset of start of central directory with respect to the starting disk number
+
+      output[op3++] = localFileSize & 0xff;
+      output[op3++] = localFileSize >> 8 & 0xff;
+      output[op3++] = localFileSize >> 16 & 0xff;
+      output[op3++] = localFileSize >> 24 & 0xff; // .ZIP file comment length
+
+      commentLength = this.comment ? this.comment.length : 0;
+      output[op3++] = commentLength & 0xff;
+      output[op3++] = commentLength >> 8 & 0xff; // .ZIP file comment
+
+      if (this.comment) {
+        {
+          output.set(this.comment, op3);
+          op3 += commentLength;
+        }
+      }
+
+      return output;
+    };
+    /**
+     * @param {!(Array.<number>|Uint8Array)} input
+     * @param {Object=} opt_params options.
+     * @return {!(Array.<number>|Uint8Array)}
+     */
+
+
+    Zlib$1.Zip.prototype.deflateWithOption = function (input, opt_params) {
+      /** @type {Zlib.RawDeflate} */
+      var deflator = new Zlib$1.RawDeflate(input, opt_params['deflateOption']);
+      return deflator.compress();
+    };
+    /**
+     * @param {(Array.<number>|Uint32Array)} key
+     * @return {number}
+     */
+
+
+    Zlib$1.Zip.prototype.getByte = function (key) {
+      /** @type {number} */
+      var tmp = key[2] & 0xffff | 2;
+      return tmp * (tmp ^ 1) >> 8 & 0xff;
+    };
+    /**
+     * @param {(Array.<number>|Uint32Array|Object)} key
+     * @param {number} n
+     * @return {number}
+     */
+
+
+    Zlib$1.Zip.prototype.encode = function (key, n) {
+      /** @type {number} */
+      var tmp = this.getByte(key);
+      this.updateKeys(key, n);
+      return tmp ^ n;
+    };
+    /**
+     * @param {(Array.<number>|Uint32Array)} key
+     * @param {number} n
+     */
+
+
+    Zlib$1.Zip.prototype.updateKeys = function (key, n) {
+      key[0] = Zlib$1.CRC32.single(key[0], n);
+      key[1] = (((key[1] + (key[0] & 0xff)) * 20173 >>> 0) * 6681 >>> 0) + 1 >>> 0;
+      key[2] = Zlib$1.CRC32.single(key[2], key[1] >>> 24);
+    };
+    /**
+     * @param {(Array.<number>|Uint8Array)} password
+     * @return {!(Array.<number>|Uint32Array|Object)}
+     */
+
+
+    Zlib$1.Zip.prototype.createEncryptionKey = function (password) {
+      /** @type {!(Array.<number>|Uint32Array)} */
+      var key = [305419896, 591751049, 878082192];
+      /** @type {number} */
+
+      var i;
+      /** @type {number} */
+
+      var il;
+
+      {
+        key = new Uint32Array(key);
+      }
+
+      for (i = 0, il = password.length; i < il; ++i) {
+        this.updateKeys(key, password[i] & 0xff);
+      }
+
+      return key;
+    };
+    /**
+     * build huffman table from length list.
+     * @param {!(Array.<number>|Uint8Array)} lengths length list.
+     * @return {!Array} huffman table.
+     */
+
+
+    Zlib$1.Huffman.buildHuffmanTable = function (lengths) {
+      /** @type {number} length list size. */
+      var listSize = lengths.length;
+      /** @type {number} max code length for table size. */
+
+      var maxCodeLength = 0;
+      /** @type {number} min code length for table size. */
+
+      var minCodeLength = Number.POSITIVE_INFINITY;
+      /** @type {number} table size. */
+
+      var size;
+      /** @type {!(Array|Uint8Array)} huffman code table. */
+
+      var table;
+      /** @type {number} bit length. */
+
+      var bitLength;
+      /** @type {number} huffman code. */
+
+      var code;
+      /**
+       * サイズが 2^maxlength 個のテーブルを埋めるためのスキップ長.
+       * @type {number} skip length for table filling.
+       */
+
+      var skip;
+      /** @type {number} reversed code. */
+
+      var reversed;
+      /** @type {number} reverse temp. */
+
+      var rtemp;
+      /** @type {number} loop counter. */
+
+      var i;
+      /** @type {number} loop limit. */
+
+      var il;
+      /** @type {number} loop counter. */
+
+      var j;
+      /** @type {number} table value. */
+
+      var value; // Math.max は遅いので最長の値は for-loop で取得する
+
+      for (i = 0, il = listSize; i < il; ++i) {
+        if (lengths[i] > maxCodeLength) {
+          maxCodeLength = lengths[i];
+        }
+
+        if (lengths[i] < minCodeLength) {
+          minCodeLength = lengths[i];
+        }
+      }
+
+      size = 1 << maxCodeLength;
+      table = new (Uint32Array )(size); // ãƒ“ãƒƒãƒˆé•·ã®çŸ­ã„é †ã‹ã‚‰ãƒãƒ•ãƒžãƒ³ç¬¦å·ã‚’å‰²ã‚Šå½“ã¦ã‚‹
+
+      for (bitLength = 1, code = 0, skip = 2; bitLength <= maxCodeLength;) {
+        for (i = 0; i < listSize; ++i) {
+          if (lengths[i] === bitLength) {
+            // ビットオーダーが逆になるためビット長分並びを反転する
+            for (reversed = 0, rtemp = code, j = 0; j < bitLength; ++j) {
+              reversed = reversed << 1 | rtemp & 1;
+              rtemp >>= 1;
+            } // 最大ビット長をもとにテーブルを作るため、
+            // 最大ビット長以外では 0 / 1 どちらでも良い箇所ができる
+            // ãã®ã©ã¡ã‚‰ã§ã‚‚è‰¯ã„å ´æ‰€ã¯åŒã˜å€¤ã§åŸ‹ã‚ã‚‹ã“ã¨ã§
+            // 本来のビット長以上のビット数取得しても問題が起こらないようにする
+
+
+            value = bitLength << 16 | i;
+
+            for (j = reversed; j < size; j += skip) {
+              table[j] = value;
+            }
+
+            ++code;
+          }
+        } // 次のビット長へ
+
+
+        ++bitLength;
+        code <<= 1;
+        skip <<= 1;
+      }
+
+      return [table, maxCodeLength, minCodeLength];
+    }; //-----------------------------------------------------------------------------
+
+    /** @define {number} buffer block size. */
+
+
+    var ZLIB_RAW_INFLATE_BUFFER_SIZE$1 = 0x8000; // [ 0x8000 >= ZLIB_BUFFER_BLOCK_SIZE ]
+    //-----------------------------------------------------------------------------
+
+    var buildHuffmanTable$1 = Zlib$1.Huffman.buildHuffmanTable;
+    /**
+     * @constructor
+     * @param {!(Uint8Array|Array.<number>)} input input buffer.
+     * @param {Object} opt_params option parameter.
+     *
+     * opt_params は以下のプロパティを指定する事ができます。
+     *   - index: input buffer の deflate コンテナの開始位置.
+     *   - blockSize: バッファのブロックサイズ.
+     *   - bufferType: Zlib.RawInflate.BufferType の値によってバッファの管理方法を指定する.
+     *   - resize: ç¢ºä¿ã—ãŸãƒãƒƒãƒ•ã‚¡ãŒå®Ÿéš›ã®å¤§ãã•ã‚ˆã‚Šå¤§ãã‹ã£ãŸå ´åˆã«åˆ‡ã‚Šè©°ã‚ã‚‹.
+     */
+
+    Zlib$1.RawInflate = function (input, opt_params) {
+      /** @type {!(Array.<number>|Uint8Array)} inflated buffer */
+      this.buffer;
+      /** @type {!Array.<(Array.<number>|Uint8Array)>} */
+
+      this.blocks = [];
+      /** @type {number} block size. */
+
+      this.bufferSize = ZLIB_RAW_INFLATE_BUFFER_SIZE$1;
+      /** @type {!number} total output buffer pointer. */
+
+      this.totalpos = 0;
+      /** @type {!number} input buffer pointer. */
+
+      this.ip = 0;
+      /** @type {!number} bit stream reader buffer. */
+
+      this.bitsbuf = 0;
+      /** @type {!number} bit stream reader buffer size. */
+
+      this.bitsbuflen = 0;
+      /** @type {!(Array.<number>|Uint8Array)} input buffer. */
+
+      this.input = new Uint8Array(input) ;
+      /** @type {!(Uint8Array|Array.<number>)} output buffer. */
+
+      this.output;
+      /** @type {!number} output buffer pointer. */
+
+      this.op;
+      /** @type {boolean} is final block flag. */
+
+      this.bfinal = false;
+      /** @type {Zlib.RawInflate.BufferType} buffer management. */
+
+      this.bufferType = Zlib$1.RawInflate.BufferType.ADAPTIVE;
+      /** @type {boolean} resize flag for memory size optimization. */
+
+      this.resize = false; // option parameters
+
+      if (opt_params || !(opt_params = {})) {
+        if (opt_params['index']) {
+          this.ip = opt_params['index'];
+        }
+
+        if (opt_params['bufferSize']) {
+          this.bufferSize = opt_params['bufferSize'];
+        }
+
+        if (opt_params['bufferType']) {
+          this.bufferType = opt_params['bufferType'];
+        }
+
+        if (opt_params['resize']) {
+          this.resize = opt_params['resize'];
+        }
+      } // initialize
+
+
+      switch (this.bufferType) {
+        case Zlib$1.RawInflate.BufferType.BLOCK:
+          this.op = Zlib$1.RawInflate.MaxBackwardLength;
+          this.output = new (Uint8Array )(Zlib$1.RawInflate.MaxBackwardLength + this.bufferSize + Zlib$1.RawInflate.MaxCopyLength);
+          break;
+
+        case Zlib$1.RawInflate.BufferType.ADAPTIVE:
+          this.op = 0;
+          this.output = new (Uint8Array )(this.bufferSize);
+          break;
+
+        default:
+          throw new Error('invalid inflate mode');
+      }
+    };
+    /**
+     * @enum {number}
+     */
+
+
+    Zlib$1.RawInflate.BufferType = {
+      BLOCK: 0,
+      ADAPTIVE: 1
+    };
+    /**
+     * decompress.
+     * @return {!(Uint8Array|Array.<number>)} inflated buffer.
+     */
+
+    Zlib$1.RawInflate.prototype.decompress = function () {
+      while (!this.bfinal) {
+        this.parseBlock();
+      }
+
+      switch (this.bufferType) {
+        case Zlib$1.RawInflate.BufferType.BLOCK:
+          return this.concatBufferBlock();
+
+        case Zlib$1.RawInflate.BufferType.ADAPTIVE:
+          return this.concatBufferDynamic();
+
+        default:
+          throw new Error('invalid inflate mode');
+      }
+    };
+    /**
+     * @const
+     * @type {number} max backward length for LZ77.
+     */
+
+
+    Zlib$1.RawInflate.MaxBackwardLength = 32768;
+    /**
+     * @const
+     * @type {number} max copy length for LZ77.
+     */
+
+    Zlib$1.RawInflate.MaxCopyLength = 258;
+    /**
+     * huffman order
+     * @const
+     * @type {!(Array.<number>|Uint8Array)}
+     */
+
+    Zlib$1.RawInflate.Order = function (table) {
+      return new Uint16Array(table) ;
+    }([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]);
+    /**
+     * huffman length code table.
+     * @const
+     * @type {!(Array.<number>|Uint16Array)}
+     */
+
+
+    Zlib$1.RawInflate.LengthCodeTable = function (table) {
+      return new Uint16Array(table) ;
+    }([0x0003, 0x0004, 0x0005, 0x0006, 0x0007, 0x0008, 0x0009, 0x000a, 0x000b, 0x000d, 0x000f, 0x0011, 0x0013, 0x0017, 0x001b, 0x001f, 0x0023, 0x002b, 0x0033, 0x003b, 0x0043, 0x0053, 0x0063, 0x0073, 0x0083, 0x00a3, 0x00c3, 0x00e3, 0x0102, 0x0102, 0x0102]);
+    /**
+     * huffman length extra-bits table.
+     * @const
+     * @type {!(Array.<number>|Uint8Array)}
+     */
+
+
+    Zlib$1.RawInflate.LengthExtraTable = function (table) {
+      return new Uint8Array(table) ;
+    }([0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0, 0, 0]);
+    /**
+     * huffman dist code table.
+     * @const
+     * @type {!(Array.<number>|Uint16Array)}
+     */
+
+
+    Zlib$1.RawInflate.DistCodeTable = function (table) {
+      return new Uint16Array(table) ;
+    }([0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0007, 0x0009, 0x000d, 0x0011, 0x0019, 0x0021, 0x0031, 0x0041, 0x0061, 0x0081, 0x00c1, 0x0101, 0x0181, 0x0201, 0x0301, 0x0401, 0x0601, 0x0801, 0x0c01, 0x1001, 0x1801, 0x2001, 0x3001, 0x4001, 0x6001]);
+    /**
+     * huffman dist extra-bits table.
+     * @const
+     * @type {!(Array.<number>|Uint8Array)}
+     */
+
+
+    Zlib$1.RawInflate.DistExtraTable = function (table) {
+      return new Uint8Array(table) ;
+    }([0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13]);
+    /**
+     * fixed huffman length code table
+     * @const
+     * @type {!Array}
+     */
+
+
+    Zlib$1.RawInflate.FixedLiteralLengthTable = function (table) {
+      return table;
+    }(function () {
+      var lengths = new (Uint8Array )(288);
+      var i, il;
+
+      for (i = 0, il = lengths.length; i < il; ++i) {
+        lengths[i] = i <= 143 ? 8 : i <= 255 ? 9 : i <= 279 ? 7 : 8;
+      }
+
+      return buildHuffmanTable$1(lengths);
+    }());
+    /**
+     * fixed huffman distance code table
+     * @const
+     * @type {!Array}
+     */
+
+
+    Zlib$1.RawInflate.FixedDistanceTable = function (table) {
+      return table;
+    }(function () {
+      var lengths = new (Uint8Array )(30);
+      var i, il;
+
+      for (i = 0, il = lengths.length; i < il; ++i) {
+        lengths[i] = 5;
+      }
+
+      return buildHuffmanTable$1(lengths);
+    }());
+    /**
+     * parse deflated block.
+     */
+
+
+    Zlib$1.RawInflate.prototype.parseBlock = function () {
+      /** @type {number} header */
+      var hdr = this.readBits(3); // BFINAL
+
+      if (hdr & 0x1) {
+        this.bfinal = true;
+      } // BTYPE
+
+
+      hdr >>>= 1;
+
+      switch (hdr) {
+        // uncompressed
+        case 0:
+          this.parseUncompressedBlock();
+          break;
+        // fixed huffman
+
+        case 1:
+          this.parseFixedHuffmanBlock();
+          break;
+        // dynamic huffman
+
+        case 2:
+          this.parseDynamicHuffmanBlock();
+          break;
+        // reserved or other
+
+        default:
+          throw new Error('unknown BTYPE: ' + hdr);
+      }
+    };
+    /**
+     * read inflate bits
+     * @param {number} length bits length.
+     * @return {number} read bits.
+     */
+
+
+    Zlib$1.RawInflate.prototype.readBits = function (length) {
+      var bitsbuf = this.bitsbuf;
+      var bitsbuflen = this.bitsbuflen;
+      var input = this.input;
+      var ip = this.ip;
+      /** @type {number} */
+
+      var inputLength = input.length;
+      /** @type {number} input and output byte. */
+
+      var octet; // input byte
+
+      if (ip + (length - bitsbuflen + 7 >> 3) >= inputLength) {
+        throw new Error('input buffer is broken');
+      } // not enough buffer
+
+
+      while (bitsbuflen < length) {
+        bitsbuf |= input[ip++] << bitsbuflen;
+        bitsbuflen += 8;
+      } // output byte
+
+
+      octet = bitsbuf & (1 << length) - 1;
+      bitsbuf >>>= length;
+      bitsbuflen -= length;
+      this.bitsbuf = bitsbuf;
+      this.bitsbuflen = bitsbuflen;
+      this.ip = ip;
+      return octet;
+    };
+    /**
+     * read huffman code using table
+     * @param {!(Array.<number>|Uint8Array|Uint16Array)} table huffman code table.
+     * @return {number} huffman code.
+     */
+
+
+    Zlib$1.RawInflate.prototype.readCodeByTable = function (table) {
+      var bitsbuf = this.bitsbuf;
+      var bitsbuflen = this.bitsbuflen;
+      var input = this.input;
+      var ip = this.ip;
+      /** @type {number} */
+
+      var inputLength = input.length;
+      /** @type {!(Array.<number>|Uint8Array)} huffman code table */
+
+      var codeTable = table[0];
+      /** @type {number} */
+
+      var maxCodeLength = table[1];
+      /** @type {number} code length & code (16bit, 16bit) */
+
+      var codeWithLength;
+      /** @type {number} code bits length */
+
+      var codeLength; // not enough buffer
+
+      while (bitsbuflen < maxCodeLength) {
+        if (ip >= inputLength) {
+          break;
+        }
+
+        bitsbuf |= input[ip++] << bitsbuflen;
+        bitsbuflen += 8;
+      } // read max length
+
+
+      codeWithLength = codeTable[bitsbuf & (1 << maxCodeLength) - 1];
+      codeLength = codeWithLength >>> 16;
+
+      if (codeLength > bitsbuflen) {
+        throw new Error('invalid code length: ' + codeLength);
+      }
+
+      this.bitsbuf = bitsbuf >> codeLength;
+      this.bitsbuflen = bitsbuflen - codeLength;
+      this.ip = ip;
+      return codeWithLength & 0xffff;
+    };
+    /**
+     * parse uncompressed block.
+     */
+
+
+    Zlib$1.RawInflate.prototype.parseUncompressedBlock = function () {
+      var input = this.input;
+      var ip = this.ip;
+      var output = this.output;
+      var op = this.op;
+      /** @type {number} */
+
+      var inputLength = input.length;
+      /** @type {number} block length */
+
+      var len;
+      /** @type {number} number for check block length */
+
+      var nlen;
+      /** @type {number} output buffer length */
+
+      var olength = output.length;
+      /** @type {number} copy counter */
+
+      var preCopy; // skip buffered header bits
+
+      this.bitsbuf = 0;
+      this.bitsbuflen = 0; // len
+
+      if (ip + 1 >= inputLength) {
+        throw new Error('invalid uncompressed block header: LEN');
+      }
+
+      len = input[ip++] | input[ip++] << 8; // nlen
+
+      if (ip + 1 >= inputLength) {
+        throw new Error('invalid uncompressed block header: NLEN');
+      }
+
+      nlen = input[ip++] | input[ip++] << 8; // check len & nlen
+
+      if (len === ~nlen) {
+        throw new Error('invalid uncompressed block header: length verify');
+      } // check size
+
+
+      if (ip + len > input.length) {
+        throw new Error('input buffer is broken');
+      } // expand buffer
+
+
+      switch (this.bufferType) {
+        case Zlib$1.RawInflate.BufferType.BLOCK:
+          // pre copy
+          while (op + len > output.length) {
+            preCopy = olength - op;
+            len -= preCopy;
+
+            {
+              output.set(input.subarray(ip, ip + preCopy), op);
+              op += preCopy;
+              ip += preCopy;
+            }
+
+            this.op = op;
+            output = this.expandBufferBlock();
+            op = this.op;
+          }
+
+          break;
+
+        case Zlib$1.RawInflate.BufferType.ADAPTIVE:
+          while (op + len > output.length) {
+            output = this.expandBufferAdaptive({
+              fixRatio: 2
+            });
+          }
+
+          break;
+
+        default:
+          throw new Error('invalid inflate mode');
+      } // copy
+
+
+      {
+        output.set(input.subarray(ip, ip + len), op);
+        op += len;
+        ip += len;
+      }
+
+      this.ip = ip;
+      this.op = op;
+      this.output = output;
+    };
+    /**
+     * parse fixed huffman block.
+     */
+
+
+    Zlib$1.RawInflate.prototype.parseFixedHuffmanBlock = function () {
+      switch (this.bufferType) {
+        case Zlib$1.RawInflate.BufferType.ADAPTIVE:
+          this.decodeHuffmanAdaptive(Zlib$1.RawInflate.FixedLiteralLengthTable, Zlib$1.RawInflate.FixedDistanceTable);
+          break;
+
+        case Zlib$1.RawInflate.BufferType.BLOCK:
+          this.decodeHuffmanBlock(Zlib$1.RawInflate.FixedLiteralLengthTable, Zlib$1.RawInflate.FixedDistanceTable);
+          break;
+
+        default:
+          throw new Error('invalid inflate mode');
+      }
+    };
+    /**
+     * parse dynamic huffman block.
+     */
+
+
+    Zlib$1.RawInflate.prototype.parseDynamicHuffmanBlock = function () {
+      /** @type {number} number of literal and length codes. */
+      var hlit = this.readBits(5) + 257;
+      /** @type {number} number of distance codes. */
+
+      var hdist = this.readBits(5) + 1;
+      /** @type {number} number of code lengths. */
+
+      var hclen = this.readBits(4) + 4;
+      /** @type {!(Uint8Array|Array.<number>)} code lengths. */
+
+      var codeLengths = new (Uint8Array )(Zlib$1.RawInflate.Order.length);
+      /** @type {!Array} code lengths table. */
+
+      var codeLengthsTable;
+      /** @type {!(Uint8Array|Array.<number>)} literal and length code table. */
+
+      var litlenTable;
+      /** @type {!(Uint8Array|Array.<number>)} distance code table. */
+
+      var distTable;
+      /** @type {!(Uint8Array|Array.<number>)} code length table. */
+
+      var lengthTable;
+      /** @type {number} */
+
+      var code;
+      /** @type {number} */
+
+      var prev;
+      /** @type {number} */
+
+      var repeat;
+      /** @type {number} loop counter. */
+
+      var i;
+      /** @type {number} loop limit. */
+
+      var il; // decode code lengths
+
+      for (i = 0; i < hclen; ++i) {
+        codeLengths[Zlib$1.RawInflate.Order[i]] = this.readBits(3);
+      }
+
+
+      codeLengthsTable = buildHuffmanTable$1(codeLengths);
+      lengthTable = new (Uint8Array )(hlit + hdist);
+
+      for (i = 0, il = hlit + hdist; i < il;) {
+        code = this.readCodeByTable(codeLengthsTable);
+
+        switch (code) {
+          case 16:
+            repeat = 3 + this.readBits(2);
+
+            while (repeat--) {
+              lengthTable[i++] = prev;
+            }
+
+            break;
+
+          case 17:
+            repeat = 3 + this.readBits(3);
+
+            while (repeat--) {
+              lengthTable[i++] = 0;
+            }
+
+            prev = 0;
+            break;
+
+          case 18:
+            repeat = 11 + this.readBits(7);
+
+            while (repeat--) {
+              lengthTable[i++] = 0;
+            }
+
+            prev = 0;
+            break;
+
+          default:
+            lengthTable[i++] = code;
+            prev = code;
+            break;
+        }
+      }
+
+      litlenTable = buildHuffmanTable$1(lengthTable.subarray(0, hlit)) ;
+      distTable = buildHuffmanTable$1(lengthTable.subarray(hlit)) ;
+
+      switch (this.bufferType) {
+        case Zlib$1.RawInflate.BufferType.ADAPTIVE:
+          this.decodeHuffmanAdaptive(litlenTable, distTable);
+          break;
+
+        case Zlib$1.RawInflate.BufferType.BLOCK:
+          this.decodeHuffmanBlock(litlenTable, distTable);
+          break;
+
+        default:
+          throw new Error('invalid inflate mode');
+      }
+    };
+    /**
+     * decode huffman code
+     * @param {!(Array.<number>|Uint16Array)} litlen literal and length code table.
+     * @param {!(Array.<number>|Uint8Array)} dist distination code table.
+     */
+
+
+    Zlib$1.RawInflate.prototype.decodeHuffmanBlock = function (litlen, dist) {
+      var output = this.output;
+      var op = this.op;
+      this.currentLitlenTable = litlen;
+      /** @type {number} output position limit. */
+
+      var olength = output.length - Zlib$1.RawInflate.MaxCopyLength;
+      /** @type {number} huffman code. */
+
+      var code;
+      /** @type {number} table index. */
+
+      var ti;
+      /** @type {number} huffman code distination. */
+
+      var codeDist;
+      /** @type {number} huffman code length. */
+
+      var codeLength;
+      var lengthCodeTable = Zlib$1.RawInflate.LengthCodeTable;
+      var lengthExtraTable = Zlib$1.RawInflate.LengthExtraTable;
+      var distCodeTable = Zlib$1.RawInflate.DistCodeTable;
+      var distExtraTable = Zlib$1.RawInflate.DistExtraTable;
+
+      while ((code = this.readCodeByTable(litlen)) !== 256) {
+        // literal
+        if (code < 256) {
+          if (op >= olength) {
+            this.op = op;
+            output = this.expandBufferBlock();
+            op = this.op;
+          }
+
+          output[op++] = code;
+          continue;
+        } // length code
+
+
+        ti = code - 257;
+        codeLength = lengthCodeTable[ti];
+
+        if (lengthExtraTable[ti] > 0) {
+          codeLength += this.readBits(lengthExtraTable[ti]);
+        } // dist code
+
+
+        code = this.readCodeByTable(dist);
+        codeDist = distCodeTable[code];
+
+        if (distExtraTable[code] > 0) {
+          codeDist += this.readBits(distExtraTable[code]);
+        } // lz77 decode
+
+
+        if (op >= olength) {
+          this.op = op;
+          output = this.expandBufferBlock();
+          op = this.op;
+        }
+
+        while (codeLength--) {
+          output[op] = output[op++ - codeDist];
+        }
+      }
+
+      while (this.bitsbuflen >= 8) {
+        this.bitsbuflen -= 8;
+        this.ip--;
+      }
+
+      this.op = op;
+    };
+    /**
+     * decode huffman code (adaptive)
+     * @param {!(Array.<number>|Uint16Array)} litlen literal and length code table.
+     * @param {!(Array.<number>|Uint8Array)} dist distination code table.
+     */
+
+
+    Zlib$1.RawInflate.prototype.decodeHuffmanAdaptive = function (litlen, dist) {
+      var output = this.output;
+      var op = this.op;
+      this.currentLitlenTable = litlen;
+      /** @type {number} output position limit. */
+
+      var olength = output.length;
+      /** @type {number} huffman code. */
+
+      var code;
+      /** @type {number} table index. */
+
+      var ti;
+      /** @type {number} huffman code distination. */
+
+      var codeDist;
+      /** @type {number} huffman code length. */
+
+      var codeLength;
+      var lengthCodeTable = Zlib$1.RawInflate.LengthCodeTable;
+      var lengthExtraTable = Zlib$1.RawInflate.LengthExtraTable;
+      var distCodeTable = Zlib$1.RawInflate.DistCodeTable;
+      var distExtraTable = Zlib$1.RawInflate.DistExtraTable;
+
+      while ((code = this.readCodeByTable(litlen)) !== 256) {
+        // literal
+        if (code < 256) {
+          if (op >= olength) {
+            output = this.expandBufferAdaptive();
+            olength = output.length;
+          }
+
+          output[op++] = code;
+          continue;
+        } // length code
+
+
+        ti = code - 257;
+        codeLength = lengthCodeTable[ti];
+
+        if (lengthExtraTable[ti] > 0) {
+          codeLength += this.readBits(lengthExtraTable[ti]);
+        } // dist code
+
+
+        code = this.readCodeByTable(dist);
+        codeDist = distCodeTable[code];
+
+        if (distExtraTable[code] > 0) {
+          codeDist += this.readBits(distExtraTable[code]);
+        } // lz77 decode
+
+
+        if (op + codeLength > olength) {
+          output = this.expandBufferAdaptive();
+          olength = output.length;
+        }
+
+        while (codeLength--) {
+          output[op] = output[op++ - codeDist];
+        }
+      }
+
+      while (this.bitsbuflen >= 8) {
+        this.bitsbuflen -= 8;
+        this.ip--;
+      }
+
+      this.op = op;
+    };
+    /**
+     * expand output buffer.
+     * @param {Object=} opt_param option parameters.
+     * @return {!(Array.<number>|Uint8Array)} output buffer.
+     */
+
+
+    Zlib$1.RawInflate.prototype.expandBufferBlock = function (opt_param) {
+      /** @type {!(Array.<number>|Uint8Array)} store buffer. */
+      var buffer = new (Uint8Array )(this.op - Zlib$1.RawInflate.MaxBackwardLength);
+      /** @type {number} backward base point */
+
+      var backward = this.op - Zlib$1.RawInflate.MaxBackwardLength;
+      var output = this.output; // copy to output buffer
+
+      {
+        buffer.set(output.subarray(Zlib$1.RawInflate.MaxBackwardLength, buffer.length));
+      }
+
+      this.blocks.push(buffer);
+      this.totalpos += buffer.length; // copy to backward buffer
+
+      {
+        output.set(output.subarray(backward, backward + Zlib$1.RawInflate.MaxBackwardLength));
+      }
+
+      this.op = Zlib$1.RawInflate.MaxBackwardLength;
+      return output;
+    };
+    /**
+     * expand output buffer. (adaptive)
+     * @param {Object=} opt_param option parameters.
+     * @return {!(Array.<number>|Uint8Array)} output buffer pointer.
+     */
+
+
+    Zlib$1.RawInflate.prototype.expandBufferAdaptive = function (opt_param) {
+      /** @type {!(Array.<number>|Uint8Array)} store buffer. */
+      var buffer;
+      /** @type {number} expantion ratio. */
+
+      var ratio = this.input.length / this.ip + 1 | 0;
+      /** @type {number} maximum number of huffman code. */
+
+      var maxHuffCode;
+      /** @type {number} new output buffer size. */
+
+      var newSize;
+      /** @type {number} max inflate size. */
+
+      var maxInflateSize;
+      var input = this.input;
+      var output = this.output;
+
+      if (opt_param) {
+        if (typeof opt_param.fixRatio === 'number') {
+          ratio = opt_param.fixRatio;
+        }
+
+        if (typeof opt_param.addRatio === 'number') {
+          ratio += opt_param.addRatio;
+        }
+      } // calculate new buffer size
+
+
+      if (ratio < 2) {
+        maxHuffCode = (input.length - this.ip) / this.currentLitlenTable[2];
+        maxInflateSize = maxHuffCode / 2 * 258 | 0;
+        newSize = maxInflateSize < output.length ? output.length + maxInflateSize : output.length << 1;
+      } else {
+        newSize = output.length * ratio;
+      } // buffer expantion
+
+
+      {
+        buffer = new Uint8Array(newSize);
+        buffer.set(output);
+      }
+
+      this.output = buffer;
+      return this.output;
+    };
+    /**
+     * concat output buffer.
+     * @return {!(Array.<number>|Uint8Array)} output buffer.
+     */
+
+
+    Zlib$1.RawInflate.prototype.concatBufferBlock = function () {
+      /** @type {number} buffer pointer. */
+      var pos = 0;
+      /** @type {number} buffer pointer. */
+
+      var limit = this.totalpos + (this.op - Zlib$1.RawInflate.MaxBackwardLength);
+      /** @type {!(Array.<number>|Uint8Array)} output block array. */
+
+      var output = this.output;
+      /** @type {!Array} blocks array. */
+
+      var blocks = this.blocks;
+      /** @type {!(Array.<number>|Uint8Array)} output block array. */
+
+      var block;
+      /** @type {!(Array.<number>|Uint8Array)} output buffer. */
+
+      var buffer = new (Uint8Array )(limit);
+      /** @type {number} loop counter. */
+
+      var i;
+      /** @type {number} loop limiter. */
+
+      var il;
+      /** @type {number} loop counter. */
+
+      var j;
+      /** @type {number} loop limiter. */
+
+      var jl; // single buffer
+
+      if (blocks.length === 0) {
+        return this.output.subarray(Zlib$1.RawInflate.MaxBackwardLength, this.op) ;
+      } // copy to buffer
+
+
+      for (i = 0, il = blocks.length; i < il; ++i) {
+        block = blocks[i];
+
+        for (j = 0, jl = block.length; j < jl; ++j) {
+          buffer[pos++] = block[j];
+        }
+      } // current buffer
+
+
+      for (i = Zlib$1.RawInflate.MaxBackwardLength, il = this.op; i < il; ++i) {
+        buffer[pos++] = output[i];
+      }
+
+      this.blocks = [];
+      this.buffer = buffer;
+      return this.buffer;
+    };
+    /**
+     * concat output buffer. (dynamic)
+     * @return {!(Array.<number>|Uint8Array)} output buffer.
+     */
+
+
+    Zlib$1.RawInflate.prototype.concatBufferDynamic = function () {
+      /** @type {Array.<number>|Uint8Array} output buffer. */
+      var buffer;
+      var op = this.op;
+
+      {
+        if (this.resize) {
+          buffer = new Uint8Array(op);
+          buffer.set(this.output.subarray(0, op));
+        } else {
+          buffer = this.output.subarray(0, op);
+        }
+      }
+
+      this.buffer = buffer;
+      return this.buffer;
+    };
+
+    var buildHuffmanTable$1 = Zlib$1.Huffman.buildHuffmanTable;
+    /**
+     * @param {!(Uint8Array|Array.<number>)} input input buffer.
+     * @param {number} ip input buffer pointer.
+     * @param {number=} opt_buffersize buffer block size.
+     * @constructor
+     */
+
+    Zlib$1.RawInflateStream = function (input, ip, opt_buffersize) {
+      /** @type {!Array.<(Array|Uint8Array)>} */
+      this.blocks = [];
+      /** @type {number} block size. */
+
+      this.bufferSize = opt_buffersize ? opt_buffersize : ZLIB_STREAM_RAW_INFLATE_BUFFER_SIZE$1;
+      /** @type {!number} total output buffer pointer. */
+
+      this.totalpos = 0;
+      /** @type {!number} input buffer pointer. */
+
+      this.ip = ip === void 0 ? 0 : ip;
+      /** @type {!number} bit stream reader buffer. */
+
+      this.bitsbuf = 0;
+      /** @type {!number} bit stream reader buffer size. */
+
+      this.bitsbuflen = 0;
+      /** @type {!(Array|Uint8Array)} input buffer. */
+
+      this.input = new Uint8Array(input) ;
+      /** @type {!(Uint8Array|Array)} output buffer. */
+
+      this.output = new (Uint8Array )(this.bufferSize);
+      /** @type {!number} output buffer pointer. */
+
+      this.op = 0;
+      /** @type {boolean} is final block flag. */
+
+      this.bfinal = false;
+      /** @type {number} uncompressed block length. */
+
+      this.blockLength;
+      /** @type {boolean} resize flag for memory size optimization. */
+
+      this.resize = false;
+      /** @type {Array} */
+
+      this.litlenTable;
+      /** @type {Array} */
+
+      this.distTable;
+      /** @type {number} */
+
+      this.sp = 0; // stream pointer
+
+      /** @type {Zlib.RawInflateStream.Status} */
+
+      this.status = Zlib$1.RawInflateStream.Status.INITIALIZED; //
+      // backup
+      //
+
+      /** @type {!number} */
+
+      this.ip_;
+      /** @type {!number} */
+
+      this.bitsbuflen_;
+      /** @type {!number} */
+
+      this.bitsbuf_;
+    };
+    /**
+     * @enum {number}
+     */
+
+
+    Zlib$1.RawInflateStream.BlockType = {
+      UNCOMPRESSED: 0,
+      FIXED: 1,
+      DYNAMIC: 2
+    };
+    /**
+     * @enum {number}
+     */
+
+    Zlib$1.RawInflateStream.Status = {
+      INITIALIZED: 0,
+      BLOCK_HEADER_START: 1,
+      BLOCK_HEADER_END: 2,
+      BLOCK_BODY_START: 3,
+      BLOCK_BODY_END: 4,
+      DECODE_BLOCK_START: 5,
+      DECODE_BLOCK_END: 6
+    };
+    /**
+     * decompress.
+     * @return {!(Uint8Array|Array)} inflated buffer.
+     */
+
+    Zlib$1.RawInflateStream.prototype.decompress = function (newInput, ip) {
+      /** @type {boolean} */
+      var stop = false;
+
+      if (newInput !== void 0) {
+        this.input = newInput;
+      }
+
+      if (ip !== void 0) {
+        this.ip = ip;
+      } // decompress
+
+
+      while (!stop) {
+        switch (this.status) {
+          // block header
+          case Zlib$1.RawInflateStream.Status.INITIALIZED:
+          case Zlib$1.RawInflateStream.Status.BLOCK_HEADER_START:
+            if (this.readBlockHeader() < 0) {
+              stop = true;
+            }
+
+            break;
+          // block body
+
+          case Zlib$1.RawInflateStream.Status.BLOCK_HEADER_END:
+          /* FALLTHROUGH */
+
+          case Zlib$1.RawInflateStream.Status.BLOCK_BODY_START:
+            switch (this.currentBlockType) {
+              case Zlib$1.RawInflateStream.BlockType.UNCOMPRESSED:
+                if (this.readUncompressedBlockHeader() < 0) {
+                  stop = true;
+                }
+
+                break;
+
+              case Zlib$1.RawInflateStream.BlockType.FIXED:
+                if (this.parseFixedHuffmanBlock() < 0) {
+                  stop = true;
+                }
+
+                break;
+
+              case Zlib$1.RawInflateStream.BlockType.DYNAMIC:
+                if (this.parseDynamicHuffmanBlock() < 0) {
+                  stop = true;
+                }
+
+                break;
+            }
+
+            break;
+          // decode data
+
+          case Zlib$1.RawInflateStream.Status.BLOCK_BODY_END:
+          case Zlib$1.RawInflateStream.Status.DECODE_BLOCK_START:
+            switch (this.currentBlockType) {
+              case Zlib$1.RawInflateStream.BlockType.UNCOMPRESSED:
+                if (this.parseUncompressedBlock() < 0) {
+                  stop = true;
+                }
+
+                break;
+
+              case Zlib$1.RawInflateStream.BlockType.FIXED:
+              /* FALLTHROUGH */
+
+              case Zlib$1.RawInflateStream.BlockType.DYNAMIC:
+                if (this.decodeHuffman() < 0) {
+                  stop = true;
+                }
+
+                break;
+            }
+
+            break;
+
+          case Zlib$1.RawInflateStream.Status.DECODE_BLOCK_END:
+            if (this.bfinal) {
+              stop = true;
+            } else {
+              this.status = Zlib$1.RawInflateStream.Status.INITIALIZED;
+            }
+
+            break;
+        }
+      }
+
+      return this.concatBuffer();
+    };
+    /**
+     * @const
+     * @type {number} max backward length for LZ77.
+     */
+
+
+    Zlib$1.RawInflateStream.MaxBackwardLength = 32768;
+    /**
+     * @const
+     * @type {number} max copy length for LZ77.
+     */
+
+    Zlib$1.RawInflateStream.MaxCopyLength = 258;
+    /**
+     * huffman order
+     * @const
+     * @type {!(Array.<number>|Uint8Array)}
+     */
+
+    Zlib$1.RawInflateStream.Order = function (table) {
+      return new Uint16Array(table) ;
+    }([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]);
+    /**
+     * huffman length code table.
+     * @const
+     * @type {!(Array.<number>|Uint16Array)}
+     */
+
+
+    Zlib$1.RawInflateStream.LengthCodeTable = function (table) {
+      return new Uint16Array(table) ;
+    }([0x0003, 0x0004, 0x0005, 0x0006, 0x0007, 0x0008, 0x0009, 0x000a, 0x000b, 0x000d, 0x000f, 0x0011, 0x0013, 0x0017, 0x001b, 0x001f, 0x0023, 0x002b, 0x0033, 0x003b, 0x0043, 0x0053, 0x0063, 0x0073, 0x0083, 0x00a3, 0x00c3, 0x00e3, 0x0102, 0x0102, 0x0102]);
+    /**
+     * huffman length extra-bits table.
+     * @const
+     * @type {!(Array.<number>|Uint8Array)}
+     */
+
+
+    Zlib$1.RawInflateStream.LengthExtraTable = function (table) {
+      return new Uint8Array(table) ;
+    }([0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0, 0, 0]);
+    /**
+     * huffman dist code table.
+     * @const
+     * @type {!(Array.<number>|Uint16Array)}
+     */
+
+
+    Zlib$1.RawInflateStream.DistCodeTable = function (table) {
+      return new Uint16Array(table) ;
+    }([0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0007, 0x0009, 0x000d, 0x0011, 0x0019, 0x0021, 0x0031, 0x0041, 0x0061, 0x0081, 0x00c1, 0x0101, 0x0181, 0x0201, 0x0301, 0x0401, 0x0601, 0x0801, 0x0c01, 0x1001, 0x1801, 0x2001, 0x3001, 0x4001, 0x6001]);
+    /**
+     * huffman dist extra-bits table.
+     * @const
+     * @type {!(Array.<number>|Uint8Array)}
+     */
+
+
+    Zlib$1.RawInflateStream.DistExtraTable = function (table) {
+      return new Uint8Array(table) ;
+    }([0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13]);
+    /**
+     * fixed huffman length code table
+     * @const
+     * @type {!Array}
+     */
+
+
+    Zlib$1.RawInflateStream.FixedLiteralLengthTable = function (table) {
+      return table;
+    }(function () {
+      var lengths = new (Uint8Array )(288);
+      var i, il;
+
+      for (i = 0, il = lengths.length; i < il; ++i) {
+        lengths[i] = i <= 143 ? 8 : i <= 255 ? 9 : i <= 279 ? 7 : 8;
+      }
+
+      return buildHuffmanTable$1(lengths);
+    }());
+    /**
+     * fixed huffman distance code table
+     * @const
+     * @type {!Array}
+     */
+
+
+    Zlib$1.RawInflateStream.FixedDistanceTable = function (table) {
+      return table;
+    }(function () {
+      var lengths = new (Uint8Array )(30);
+      var i, il;
+
+      for (i = 0, il = lengths.length; i < il; ++i) {
+        lengths[i] = 5;
+      }
+
+      return buildHuffmanTable$1(lengths);
+    }());
+    /**
+     * parse deflated block.
+     */
+
+
+    Zlib$1.RawInflateStream.prototype.readBlockHeader = function () {
+      /** @type {number} header */
+      var hdr;
+      this.status = Zlib$1.RawInflateStream.Status.BLOCK_HEADER_START;
+      this.save_();
+
+      if ((hdr = this.readBits(3)) < 0) {
+        this.restore_();
+        return -1;
+      } // BFINAL
+
+
+      if (hdr & 0x1) {
+        this.bfinal = true;
+      } // BTYPE
+
+
+      hdr >>>= 1;
+
+      switch (hdr) {
+        case 0:
+          // uncompressed
+          this.currentBlockType = Zlib$1.RawInflateStream.BlockType.UNCOMPRESSED;
+          break;
+
+        case 1:
+          // fixed huffman
+          this.currentBlockType = Zlib$1.RawInflateStream.BlockType.FIXED;
+          break;
+
+        case 2:
+          // dynamic huffman
+          this.currentBlockType = Zlib$1.RawInflateStream.BlockType.DYNAMIC;
+          break;
+
+        default:
+          // reserved or other
+          throw new Error('unknown BTYPE: ' + hdr);
+      }
+
+      this.status = Zlib$1.RawInflateStream.Status.BLOCK_HEADER_END;
+    };
+    /**
+     * read inflate bits
+     * @param {number} length bits length.
+     * @return {number} read bits.
+     */
+
+
+    Zlib$1.RawInflateStream.prototype.readBits = function (length) {
+      var bitsbuf = this.bitsbuf;
+      var bitsbuflen = this.bitsbuflen;
+      var input = this.input;
+      var ip = this.ip;
+      /** @type {number} input and output byte. */
+
+      var octet; // not enough buffer
+
+      while (bitsbuflen < length) {
+        // input byte
+        if (input.length <= ip) {
+          return -1;
+        }
+
+        octet = input[ip++]; // concat octet
+
+        bitsbuf |= octet << bitsbuflen;
+        bitsbuflen += 8;
+      } // output byte
+
+
+      octet = bitsbuf & (1 << length) - 1;
+      bitsbuf >>>= length;
+      bitsbuflen -= length;
+      this.bitsbuf = bitsbuf;
+      this.bitsbuflen = bitsbuflen;
+      this.ip = ip;
+      return octet;
+    };
+    /**
+     * read huffman code using table
+     * @param {Array} table huffman code table.
+     * @return {number} huffman code.
+     */
+
+
+    Zlib$1.RawInflateStream.prototype.readCodeByTable = function (table) {
+      var bitsbuf = this.bitsbuf;
+      var bitsbuflen = this.bitsbuflen;
+      var input = this.input;
+      var ip = this.ip;
+      /** @type {!(Array|Uint8Array)} huffman code table */
+
+      var codeTable = table[0];
+      /** @type {number} */
+
+      var maxCodeLength = table[1];
+      /** @type {number} input byte */
+
+      var octet;
+      /** @type {number} code length & code (16bit, 16bit) */
+
+      var codeWithLength;
+      /** @type {number} code bits length */
+
+      var codeLength; // not enough buffer
+
+      while (bitsbuflen < maxCodeLength) {
+        if (input.length <= ip) {
+          return -1;
+        }
+
+        octet = input[ip++];
+        bitsbuf |= octet << bitsbuflen;
+        bitsbuflen += 8;
+      } // read max length
+
+
+      codeWithLength = codeTable[bitsbuf & (1 << maxCodeLength) - 1];
+      codeLength = codeWithLength >>> 16;
+
+      if (codeLength > bitsbuflen) {
+        throw new Error('invalid code length: ' + codeLength);
+      }
+
+      this.bitsbuf = bitsbuf >> codeLength;
+      this.bitsbuflen = bitsbuflen - codeLength;
+      this.ip = ip;
+      return codeWithLength & 0xffff;
+    };
+    /**
+     * read uncompressed block header
+     */
+
+
+    Zlib$1.RawInflateStream.prototype.readUncompressedBlockHeader = function () {
+      /** @type {number} block length */
+      var len;
+      /** @type {number} number for check block length */
+
+      var nlen;
+      var input = this.input;
+      var ip = this.ip;
+      this.status = Zlib$1.RawInflateStream.Status.BLOCK_BODY_START;
+
+      if (ip + 4 >= input.length) {
+        return -1;
+      }
+
+      len = input[ip++] | input[ip++] << 8;
+      nlen = input[ip++] | input[ip++] << 8; // check len & nlen
+
+      if (len === ~nlen) {
+        throw new Error('invalid uncompressed block header: length verify');
+      } // skip buffered header bits
+
+
+      this.bitsbuf = 0;
+      this.bitsbuflen = 0;
+      this.ip = ip;
+      this.blockLength = len;
+      this.status = Zlib$1.RawInflateStream.Status.BLOCK_BODY_END;
+    };
+    /**
+     * parse uncompressed block.
+     */
+
+
+    Zlib$1.RawInflateStream.prototype.parseUncompressedBlock = function () {
+      var input = this.input;
+      var ip = this.ip;
+      var output = this.output;
+      var op = this.op;
+      var len = this.blockLength;
+      this.status = Zlib$1.RawInflateStream.Status.DECODE_BLOCK_START; // copy
+      // XXX: ã¨ã‚Šã‚ãˆãšç´ ç›´ã«ã‚³ãƒ”ãƒ¼
+
+      while (len--) {
+        if (op === output.length) {
+          output = this.expandBuffer({
+            fixRatio: 2
+          });
+        } // not enough input buffer
+
+
+        if (ip >= input.length) {
+          this.ip = ip;
+          this.op = op;
+          this.blockLength = len + 1; // コピーしてないので戻す
+
+          return -1;
+        }
+
+        output[op++] = input[ip++];
+      }
+
+      if (len < 0) {
+        this.status = Zlib$1.RawInflateStream.Status.DECODE_BLOCK_END;
+      }
+
+      this.ip = ip;
+      this.op = op;
+      return 0;
+    };
+    /**
+     * parse fixed huffman block.
+     */
+
+
+    Zlib$1.RawInflateStream.prototype.parseFixedHuffmanBlock = function () {
+      this.status = Zlib$1.RawInflateStream.Status.BLOCK_BODY_START;
+      this.litlenTable = Zlib$1.RawInflateStream.FixedLiteralLengthTable;
+      this.distTable = Zlib$1.RawInflateStream.FixedDistanceTable;
+      this.status = Zlib$1.RawInflateStream.Status.BLOCK_BODY_END;
+      return 0;
+    };
+    /**
+     * オブジェクトのコンテキストを別のプロパティに退避する.
+     * @private
+     */
+
+
+    Zlib$1.RawInflateStream.prototype.save_ = function () {
+      this.ip_ = this.ip;
+      this.bitsbuflen_ = this.bitsbuflen;
+      this.bitsbuf_ = this.bitsbuf;
+    };
+    /**
+     * 別のプロパティに退避したコンテキストを復元する.
+     * @private
+     */
+
+
+    Zlib$1.RawInflateStream.prototype.restore_ = function () {
+      this.ip = this.ip_;
+      this.bitsbuflen = this.bitsbuflen_;
+      this.bitsbuf = this.bitsbuf_;
+    };
+    /**
+     * parse dynamic huffman block.
+     */
+
+
+    Zlib$1.RawInflateStream.prototype.parseDynamicHuffmanBlock = function () {
+      /** @type {number} number of literal and length codes. */
+      var hlit;
+      /** @type {number} number of distance codes. */
+
+      var hdist;
+      /** @type {number} number of code lengths. */
+
+      var hclen;
+      /** @type {!(Uint8Array|Array)} code lengths. */
+
+      var codeLengths = new (Uint8Array )(Zlib$1.RawInflateStream.Order.length);
+      /** @type {!Array} code lengths table. */
+
+      var codeLengthsTable;
+      this.status = Zlib$1.RawInflateStream.Status.BLOCK_BODY_START;
+      this.save_();
+      hlit = this.readBits(5) + 257;
+      hdist = this.readBits(5) + 1;
+      hclen = this.readBits(4) + 4;
+
+      if (hlit < 0 || hdist < 0 || hclen < 0) {
+        this.restore_();
+        return -1;
+      }
+
+      try {
+        parseDynamicHuffmanBlockImpl.call(this);
+      } catch (e) {
+        this.restore_();
+        return -1;
+      }
+
+      function parseDynamicHuffmanBlockImpl() {
+        /** @type {number} */
+        var bits;
+        var code;
+        var prev = 0;
+        var repeat;
+        /** @type {!(Uint8Array|Array.<number>)} code length table. */
+
+        var lengthTable;
+        /** @type {number} loop counter. */
+
+        var i;
+        /** @type {number} loop limit. */
+
+        var il; // decode code lengths
+
+        for (i = 0; i < hclen; ++i) {
+          if ((bits = this.readBits(3)) < 0) {
+            throw new Error('not enough input');
+          }
+
+          codeLengths[Zlib$1.RawInflateStream.Order[i]] = bits;
+        } // decode length table
+
+
+        codeLengthsTable = buildHuffmanTable$1(codeLengths);
+        lengthTable = new (Uint8Array )(hlit + hdist);
+
+        for (i = 0, il = hlit + hdist; i < il;) {
+          code = this.readCodeByTable(codeLengthsTable);
+
+          if (code < 0) {
+            throw new Error('not enough input');
+          }
+
+          switch (code) {
+            case 16:
+              if ((bits = this.readBits(2)) < 0) {
+                throw new Error('not enough input');
+              }
+
+              repeat = 3 + bits;
+
+              while (repeat--) {
+                lengthTable[i++] = prev;
+              }
+
+              break;
+
+            case 17:
+              if ((bits = this.readBits(3)) < 0) {
+                throw new Error('not enough input');
+              }
+
+              repeat = 3 + bits;
+
+              while (repeat--) {
+                lengthTable[i++] = 0;
+              }
+
+              prev = 0;
+              break;
+
+            case 18:
+              if ((bits = this.readBits(7)) < 0) {
+                throw new Error('not enough input');
+              }
+
+              repeat = 11 + bits;
+
+              while (repeat--) {
+                lengthTable[i++] = 0;
+              }
+
+              prev = 0;
+              break;
+
+            default:
+              lengthTable[i++] = code;
+              prev = code;
+              break;
+          }
+        } // literal and length code
+        this.litlenTable = buildHuffmanTable$1(lengthTable.subarray(0, hlit)) ;
+        this.distTable = buildHuffmanTable$1(lengthTable.subarray(hlit)) ;
+      }
+
+      this.status = Zlib$1.RawInflateStream.Status.BLOCK_BODY_END;
+      return 0;
+    };
+    /**
+     * decode huffman code (dynamic)
+     * @return {(number|undefined)} -1 is error.
+     */
+
+
+    Zlib$1.RawInflateStream.prototype.decodeHuffman = function () {
+      var output = this.output;
+      var op = this.op;
+      /** @type {number} huffman code. */
+
+      var code;
+      /** @type {number} table index. */
+
+      var ti;
+      /** @type {number} huffman code distination. */
+
+      var codeDist;
+      /** @type {number} huffman code length. */
+
+      var codeLength;
+      var litlen = this.litlenTable;
+      var dist = this.distTable;
+      var olength = output.length;
+      var bits;
+      this.status = Zlib$1.RawInflateStream.Status.DECODE_BLOCK_START;
+
+      while (true) {
+        this.save_();
+        code = this.readCodeByTable(litlen);
+
+        if (code < 0) {
+          this.op = op;
+          this.restore_();
+          return -1;
+        }
+
+        if (code === 256) {
+          break;
+        } // literal
+
+
+        if (code < 256) {
+          if (op === olength) {
+            output = this.expandBuffer();
+            olength = output.length;
+          }
+
+          output[op++] = code;
+          continue;
+        } // length code
+
+
+        ti = code - 257;
+        codeLength = Zlib$1.RawInflateStream.LengthCodeTable[ti];
+
+        if (Zlib$1.RawInflateStream.LengthExtraTable[ti] > 0) {
+          bits = this.readBits(Zlib$1.RawInflateStream.LengthExtraTable[ti]);
+
+          if (bits < 0) {
+            this.op = op;
+            this.restore_();
+            return -1;
+          }
+
+          codeLength += bits;
+        } // dist code
+
+
+        code = this.readCodeByTable(dist);
+
+        if (code < 0) {
+          this.op = op;
+          this.restore_();
+          return -1;
+        }
+
+        codeDist = Zlib$1.RawInflateStream.DistCodeTable[code];
+
+        if (Zlib$1.RawInflateStream.DistExtraTable[code] > 0) {
+          bits = this.readBits(Zlib$1.RawInflateStream.DistExtraTable[code]);
+
+          if (bits < 0) {
+            this.op = op;
+            this.restore_();
+            return -1;
+          }
+
+          codeDist += bits;
+        } // lz77 decode
+
+
+        if (op + codeLength >= olength) {
+          output = this.expandBuffer();
+          olength = output.length;
+        }
+
+        while (codeLength--) {
+          output[op] = output[op++ - codeDist];
+        } // break
+
+
+        if (this.ip === this.input.length) {
+          this.op = op;
+          return -1;
+        }
+      }
+
+      while (this.bitsbuflen >= 8) {
+        this.bitsbuflen -= 8;
+        this.ip--;
+      }
+
+      this.op = op;
+      this.status = Zlib$1.RawInflateStream.Status.DECODE_BLOCK_END;
+    };
+    /**
+     * expand output buffer. (dynamic)
+     * @param {Object=} opt_param option parameters.
+     * @return {!(Array|Uint8Array)} output buffer pointer.
+     */
+
+
+    Zlib$1.RawInflateStream.prototype.expandBuffer = function (opt_param) {
+      /** @type {!(Array|Uint8Array)} store buffer. */
+      var buffer;
+      /** @type {number} expantion ratio. */
+
+      var ratio = this.input.length / this.ip + 1 | 0;
+      /** @type {number} maximum number of huffman code. */
+
+      var maxHuffCode;
+      /** @type {number} new output buffer size. */
+
+      var newSize;
+      /** @type {number} max inflate size. */
+
+      var maxInflateSize;
+      var input = this.input;
+      var output = this.output;
+
+      if (opt_param) {
+        if (typeof opt_param.fixRatio === 'number') {
+          ratio = opt_param.fixRatio;
+        }
+
+        if (typeof opt_param.addRatio === 'number') {
+          ratio += opt_param.addRatio;
+        }
+      } // calculate new buffer size
+
+
+      if (ratio < 2) {
+        maxHuffCode = (input.length - this.ip) / this.litlenTable[2];
+        maxInflateSize = maxHuffCode / 2 * 258 | 0;
+        newSize = maxInflateSize < output.length ? output.length + maxInflateSize : output.length << 1;
+      } else {
+        newSize = output.length * ratio;
+      } // buffer expantion
+
+
+      {
+        buffer = new Uint8Array(newSize);
+        buffer.set(output);
+      }
+
+      this.output = buffer;
+      return this.output;
+    };
+    /**
+     * concat output buffer. (dynamic)
+     * @return {!(Array|Uint8Array)} output buffer.
+     */
+
+
+    Zlib$1.RawInflateStream.prototype.concatBuffer = function () {
+      /** @type {!(Array|Uint8Array)} output buffer. */
+      var buffer;
+      /** @type {number} */
+
+      var op = this.op;
+      /** @type {Uint8Array} */
+
+      var tmp;
+
+      if (this.resize) {
+        {
+          buffer = new Uint8Array(this.output.subarray(this.sp, op));
+        }
+      } else {
+        buffer = this.output.subarray(this.sp, op) ;
+      }
+
+      this.sp = op; // compaction
+
+      if (op > Zlib$1.RawInflateStream.MaxBackwardLength + this.bufferSize) {
+        this.op = this.sp = Zlib$1.RawInflateStream.MaxBackwardLength;
+
+        {
+          tmp = this.output;
+          this.output = new Uint8Array(this.bufferSize + Zlib$1.RawInflateStream.MaxBackwardLength);
+          this.output.set(tmp.subarray(op - Zlib$1.RawInflateStream.MaxBackwardLength, op));
+        }
+      }
+
+      return buffer;
+    };
+    /**
+     * @constructor
+     * @param {!(Uint8Array|Array)} input deflated buffer.
+     * @param {Object=} opt_params option parameters.
+     *
+     * opt_params は以下のプロパティを指定する事ができます。
+     *   - index: input buffer の deflate コンテナの開始位置.
+     *   - blockSize: バッファのブロックサイズ.
+     *   - verify: 伸張が終わった後 adler-32 checksum の検証を行うか.
+     *   - bufferType: Zlib.Inflate.BufferType の値によってバッファの管理方法を指定する.
+     *       Zlib.Inflate.BufferType は Zlib.RawInflate.BufferType のエイリアス.
+     */
+
+
+    Zlib$1.Inflate = function (input, opt_params) {
+      /** @type {number} */
+
+      var cmf;
+      /** @type {number} */
+
+      var flg;
+      /** @type {!(Uint8Array|Array)} */
+
+      this.input = input;
+      /** @type {number} */
+
+      this.ip = 0;
+      /** @type {Zlib.RawInflate} */
+
+      this.rawinflate;
+      /** @type {(boolean|undefined)} verify flag. */
+
+      this.verify; // option parameters
+
+      if (opt_params || !(opt_params = {})) {
+        if (opt_params['index']) {
+          this.ip = opt_params['index'];
+        }
+
+        if (opt_params['verify']) {
+          this.verify = opt_params['verify'];
+        }
+      } // Compression Method and Flags
+
+
+      cmf = input[this.ip++];
+      flg = input[this.ip++]; // compression method
+
+      switch (cmf & 0x0f) {
+        case Zlib$1.CompressionMethod.DEFLATE:
+          this.method = Zlib$1.CompressionMethod.DEFLATE;
+          break;
+
+        default:
+          throw new Error('unsupported compression method');
+      } // fcheck
+
+
+      if (((cmf << 8) + flg) % 31 !== 0) {
+        throw new Error('invalid fcheck flag:' + ((cmf << 8) + flg) % 31);
+      } // fdict (not supported)
+
+
+      if (flg & 0x20) {
+        throw new Error('fdict flag is not supported');
+      } // RawInflate
+
+
+      this.rawinflate = new Zlib$1.RawInflate(input, {
+        'index': this.ip,
+        'bufferSize': opt_params['bufferSize'],
+        'bufferType': opt_params['bufferType'],
+        'resize': opt_params['resize']
+      });
+    };
+    /**
+     * @enum {number}
+     */
+
+
+    Zlib$1.Inflate.BufferType = Zlib$1.RawInflate.BufferType;
+    /**
+     * decompress.
+     * @return {!(Uint8Array|Array)} inflated buffer.
+     */
+
+    Zlib$1.Inflate.prototype.decompress = function () {
+      /** @type {!(Array|Uint8Array)} input buffer. */
+      var input = this.input;
+      /** @type {!(Uint8Array|Array)} inflated buffer. */
+
+      var buffer;
+      /** @type {number} adler-32 checksum */
+
+      var adler32;
+      buffer = this.rawinflate.decompress();
+      this.ip = this.rawinflate.ip; // verify adler-32
+
+      if (this.verify) {
+        adler32 = (input[this.ip++] << 24 | input[this.ip++] << 16 | input[this.ip++] << 8 | input[this.ip++]) >>> 0;
+
+        if (adler32 !== Zlib$1.Adler32(buffer)) {
+          throw new Error('invalid adler-32 checksum');
+        }
+      }
+
+      return buffer;
+    };
+    /* vim:set expandtab ts=2 sw=2 tw=80: */
+
+    /**
+     * @param {!(Uint8Array|Array)} input deflated buffer.
+     * @constructor
+     */
+
+
+    Zlib$1.InflateStream = function (input) {
+      /** @type {!(Uint8Array|Array)} */
+      this.input = input === void 0 ? new (Uint8Array )() : input;
+      /** @type {number} */
+
+      this.ip = 0;
+      /** @type {Zlib.RawInflateStream} */
+
+      this.rawinflate = new Zlib$1.RawInflateStream(this.input, this.ip);
+      /** @type {Zlib.CompressionMethod} */
+
+      this.method;
+      /** @type {!(Array|Uint8Array)} */
+
+      this.output = this.rawinflate.output;
+    };
+    /**
+     * decompress.
+     * @return {!(Uint8Array|Array)} inflated buffer.
+     */
+
+
+    Zlib$1.InflateStream.prototype.decompress = function (input) {
+      /** @type {!(Uint8Array|Array)} inflated buffer. */
+      var buffer;
+      // XXX Array, Uint8Array のチェックを行うか確認する
+
+      if (input !== void 0) {
+        {
+          var tmp = new Uint8Array(this.input.length + input.length);
+          tmp.set(this.input, 0);
+          tmp.set(input, this.input.length);
+          this.input = tmp;
+        }
+      }
+
+      if (this.method === void 0) {
+        if (this.readHeader() < 0) {
+          return new (Uint8Array )();
+        }
+      }
+
+      buffer = this.rawinflate.decompress(this.input, this.ip);
+
+      if (this.rawinflate.ip !== 0) {
+        this.input = this.input.subarray(this.rawinflate.ip) ;
+        this.ip = 0;
+      } // verify adler-32
+
+      /*
+      if (this.verify) {
+        adler32 =
+          input[this.ip++] << 24 | input[this.ip++] << 16 |
+          input[this.ip++] << 8 | input[this.ip++];
+         if (adler32 !== Zlib.Adler32(buffer)) {
+          throw new Error('invalid adler-32 checksum');
+        }
+      }
+      */
+
+
+      return buffer;
+    };
+
+    Zlib$1.InflateStream.prototype.readHeader = function () {
+      var ip = this.ip;
+      var input = this.input; // Compression Method and Flags
+
+      var cmf = input[ip++];
+      var flg = input[ip++];
+
+      if (cmf === void 0 || flg === void 0) {
+        return -1;
+      } // compression method
+
+
+      switch (cmf & 0x0f) {
+        case Zlib$1.CompressionMethod.DEFLATE:
+          this.method = Zlib$1.CompressionMethod.DEFLATE;
+          break;
+
+        default:
+          throw new Error('unsupported compression method');
+      } // fcheck
+
+
+      if (((cmf << 8) + flg) % 31 !== 0) {
+        throw new Error('invalid fcheck flag:' + ((cmf << 8) + flg) % 31);
+      } // fdict (not supported)
+
+
+      if (flg & 0x20) {
+        throw new Error('fdict flag is not supported');
+      }
+
+      this.ip = ip;
+    };
+    /**
+     * @fileoverview GZIP (RFC1952) 展開コンテナ実装.
+     */
+
+    /**
+     * @constructor
+     * @param {!(Array|Uint8Array)} input input buffer.
+     * @param {Object=} opt_params option parameters.
+     */
+
+
+    Zlib$1.Gunzip = function (input, opt_params) {
+      /** @type {!(Array.<number>|Uint8Array)} input buffer. */
+      this.input = input;
+      /** @type {number} input buffer pointer. */
+
+      this.ip = 0;
+      /** @type {Array.<Zlib.GunzipMember>} */
+
+      this.member = [];
+      /** @type {boolean} */
+
+      this.decompressed = false;
+    };
+    /**
+     * @return {Array.<Zlib.GunzipMember>}
+     */
+
+
+    Zlib$1.Gunzip.prototype.getMembers = function () {
+      if (!this.decompressed) {
+        this.decompress();
+      }
+
+      return this.member.slice();
+    };
+    /**
+     * inflate gzip data.
+     * @return {!(Array.<number>|Uint8Array)} inflated buffer.
+     */
+
+
+    Zlib$1.Gunzip.prototype.decompress = function () {
+      /** @type {number} input length. */
+      var il = this.input.length;
+
+      while (this.ip < il) {
+        this.decodeMember();
+      }
+
+      this.decompressed = true;
+      return this.concatMember();
+    };
+    /**
+     * decode gzip member.
+     */
+
+
+    Zlib$1.Gunzip.prototype.decodeMember = function () {
+      /** @type {Zlib.GunzipMember} */
+      var member = new Zlib$1.GunzipMember();
+      /** @type {number} */
+
+      var isize;
+      /** @type {Zlib.RawInflate} RawInflate implementation. */
+
+      var rawinflate;
+      /** @type {!(Array.<number>|Uint8Array)} inflated data. */
+
+      var inflated;
+      /** @type {number} inflate size */
+
+      var inflen;
+      /** @type {number} character code */
+
+      var c;
+      /** @type {number} character index in string. */
+
+      var ci;
+      /** @type {Array.<string>} character array. */
+
+      var str;
+      /** @type {number} modification time. */
+
+      var mtime;
+      /** @type {number} */
+
+      var crc32;
+      var input = this.input;
+      var ip = this.ip;
+      member.id1 = input[ip++];
+      member.id2 = input[ip++]; // check signature
+
+      if (member.id1 !== 0x1f || member.id2 !== 0x8b) {
+        throw new Error('invalid file signature:' + member.id1 + ',' + member.id2);
+      } // check compression method
+
+
+      member.cm = input[ip++];
+
+      switch (member.cm) {
+        case 8:
+          /* XXX: use Zlib const */
+          break;
+
+        default:
+          throw new Error('unknown compression method: ' + member.cm);
+      } // flags
+
+
+      member.flg = input[ip++]; // modification time
+
+      mtime = input[ip++] | input[ip++] << 8 | input[ip++] << 16 | input[ip++] << 24;
+      member.mtime = new Date(mtime * 1000); // extra flags
+
+      member.xfl = input[ip++]; // operating system
+
+      member.os = input[ip++]; // extra
+
+      if ((member.flg & Zlib$1.Gzip.FlagsMask.FEXTRA) > 0) {
+        member.xlen = input[ip++] | input[ip++] << 8;
+        ip = this.decodeSubField(ip, member.xlen);
+      } // fname
+
+
+      if ((member.flg & Zlib$1.Gzip.FlagsMask.FNAME) > 0) {
+        for (str = [], ci = 0; (c = input[ip++]) > 0;) {
+          str[ci++] = String.fromCharCode(c);
+        }
+
+        member.name = str.join('');
+      } // fcomment
+
+
+      if ((member.flg & Zlib$1.Gzip.FlagsMask.FCOMMENT) > 0) {
+        for (str = [], ci = 0; (c = input[ip++]) > 0;) {
+          str[ci++] = String.fromCharCode(c);
+        }
+
+        member.comment = str.join('');
+      } // fhcrc
+
+
+      if ((member.flg & Zlib$1.Gzip.FlagsMask.FHCRC) > 0) {
+        member.crc16 = Zlib$1.CRC32.calc(input, 0, ip) & 0xffff;
+
+        if (member.crc16 !== (input[ip++] | input[ip++] << 8)) {
+          throw new Error('invalid header crc16');
+        }
+      } // isize を事前に取得すると展開後のサイズが分かるため、
+      // inflate処理のバッファサイズが事前に分かり、高速になる
+
+
+      isize = input[input.length - 4] | input[input.length - 3] << 8 | input[input.length - 2] << 16 | input[input.length - 1] << 24; // isize の妥当性チェック
+      // ハフマン符号では最小 2-bit のため、最大で 1/4 になる
+      // LZ77 符号では 長さと距離 2-Byte で最大 258-Byte を表現できるため、
+      // 1/128 になるとする
+      // ここから入力バッファの残りが isize の 512 倍以上だったら
+      // サイズ指定のバッファ確保は行わない事とする
+
+      if (input.length - ip -
+      /* CRC-32 */
+      4 -
+      /* ISIZE */
+      4 < isize * 512) {
+        inflen = isize;
+      } // compressed block
+
+
+      rawinflate = new Zlib$1.RawInflate(input, {
+        'index': ip,
+        'bufferSize': inflen
+      });
+      member.data = inflated = rawinflate.decompress();
+      ip = rawinflate.ip; // crc32
+
+      member.crc32 = crc32 = (input[ip++] | input[ip++] << 8 | input[ip++] << 16 | input[ip++] << 24) >>> 0;
+
+      if (Zlib$1.CRC32.calc(inflated) !== crc32) {
+        throw new Error('invalid CRC-32 checksum: 0x' + Zlib$1.CRC32.calc(inflated).toString(16) + ' / 0x' + crc32.toString(16));
+      } // input size
+
+
+      member.isize = isize = (input[ip++] | input[ip++] << 8 | input[ip++] << 16 | input[ip++] << 24) >>> 0;
+
+      if ((inflated.length & 0xffffffff) !== isize) {
+        throw new Error('invalid input size: ' + (inflated.length & 0xffffffff) + ' / ' + isize);
+      }
+
+      this.member.push(member);
+      this.ip = ip;
+    };
+    /**
+     * サブフィールドのデコード
+     * XXX: 現在は何もせずスキップする
+     */
+
+
+    Zlib$1.Gunzip.prototype.decodeSubField = function (ip, length) {
+      return ip + length;
+    };
+    /**
+     * @return {!(Array.<number>|Uint8Array)}
+     */
+
+
+    Zlib$1.Gunzip.prototype.concatMember = function () {
+      /** @type {Array.<Zlib.GunzipMember>} */
+      var member = this.member;
+      /** @type {number} */
+
+      var i;
+      /** @type {number} */
+
+      var il;
+      /** @type {number} */
+
+      var p = 0;
+      /** @type {number} */
+
+      var size = 0;
+      /** @type {!(Array.<number>|Uint8Array)} */
+
+      var buffer;
+
+      for (i = 0, il = member.length; i < il; ++i) {
+        size += member[i].data.length;
+      }
+
+      {
+        buffer = new Uint8Array(size);
+
+        for (i = 0; i < il; ++i) {
+          buffer.set(member[i].data, p);
+          p += member[i].data.length;
+        }
+      }
+
+      return buffer;
+    };
+    /**
+     * @constructor
+     */
+
+
+    Zlib$1.GunzipMember = function () {
+      /** @type {number} signature first byte. */
+      this.id1;
+      /** @type {number} signature second byte. */
+
+      this.id2;
+      /** @type {number} compression method. */
+
+      this.cm;
+      /** @type {number} flags. */
+
+      this.flg;
+      /** @type {Date} modification time. */
+
+      this.mtime;
+      /** @type {number} extra flags. */
+
+      this.xfl;
+      /** @type {number} operating system number. */
+
+      this.os;
+      /** @type {number} CRC-16 value for FHCRC flag. */
+
+      this.crc16;
+      /** @type {number} extra length. */
+
+      this.xlen;
+      /** @type {number} CRC-32 value for verification. */
+
+      this.crc32;
+      /** @type {number} input size modulo 32 value. */
+
+      this.isize;
+      /** @type {string} filename. */
+
+      this.name;
+      /** @type {string} comment. */
+
+      this.comment;
+      /** @type {!(Uint8Array|Array.<number>)} */
+
+      this.data;
+    };
+
+    Zlib$1.GunzipMember.prototype.getName = function () {
+      return this.name;
+    };
+
+    Zlib$1.GunzipMember.prototype.getData = function () {
+      return this.data;
+    };
+
+    Zlib$1.GunzipMember.prototype.getMtime = function () {
+      return this.mtime;
+    };
+    /**
+     * @fileoverview GZIP (RFC1952) 実装.
+     */
+
+    /**
+     * @constructor
+     * @param {!(Array|Uint8Array)} input input buffer.
+     * @param {Object=} opt_params option parameters.
+     */
+
+
+    Zlib$1.Gzip = function (input, opt_params) {
+      /** @type {!(Array.<number>|Uint8Array)} input buffer. */
+      this.input = input;
+      /** @type {number} input buffer pointer. */
+
+      this.ip = 0;
+      /** @type {!(Array.<number>|Uint8Array)} output buffer. */
+
+      this.output;
+      /** @type {number} output buffer. */
+
+      this.op = 0;
+      /** @type {!Object} flags option flags. */
+
+      this.flags = {};
+      /** @type {!string} filename. */
+
+      this.filename;
+      /** @type {!string} comment. */
+
+      this.comment;
+      /** @type {!Object} deflate options. */
+
+      this.deflateOptions; // option parameters
+
+      if (opt_params) {
+        if (opt_params['flags']) {
+          this.flags = opt_params['flags'];
+        }
+
+        if (typeof opt_params['filename'] === 'string') {
+          this.filename = opt_params['filename'];
+        }
+
+        if (typeof opt_params['comment'] === 'string') {
+          this.comment = opt_params['comment'];
+        }
+
+        if (opt_params['deflateOptions']) {
+          this.deflateOptions = opt_params['deflateOptions'];
+        }
+      }
+
+      if (!this.deflateOptions) {
+        this.deflateOptions = {};
+      }
+    };
+    /**
+     * @type {number}
+     * @const
+     */
+
+
+    Zlib$1.Gzip.DefaultBufferSize = 0x8000;
+    /**
+     * encode gzip members.
+     * @return {!(Array|Uint8Array)} gzip binary array.
+     */
+
+    Zlib$1.Gzip.prototype.compress = function () {
+      /** @type {number} flags. */
+      var flg;
+      /** @type {number} modification time. */
+
+      var mtime;
+      /** @type {number} CRC-16 value for FHCRC flag. */
+
+      var crc16;
+      /** @type {number} CRC-32 value for verification. */
+
+      var crc32;
+      /** @type {!Zlib.RawDeflate} raw deflate object. */
+
+      var rawdeflate;
+      /** @type {number} character code */
+
+      var c;
+      /** @type {number} loop counter. */
+
+      var i;
+      /** @type {number} loop limiter. */
+
+      var il;
+      /** @type {!(Array|Uint8Array)} output buffer. */
+
+      var output = new (Uint8Array )(Zlib$1.Gzip.DefaultBufferSize);
+      /** @type {number} output buffer pointer. */
+
+      var op = 0;
+      var input = this.input;
+      var ip = this.ip;
+      var filename = this.filename;
+      var comment = this.comment; // check signature
+
+      output[op++] = 0x1f;
+      output[op++] = 0x8b; // check compression method
+
+      output[op++] = 8;
+      /* XXX: use Zlib const */
+      // flags
+
+      flg = 0;
+      if (this.flags['fname']) flg |= Zlib$1.Gzip.FlagsMask.FNAME;
+      if (this.flags['fcomment']) flg |= Zlib$1.Gzip.FlagsMask.FCOMMENT;
+      if (this.flags['fhcrc']) flg |= Zlib$1.Gzip.FlagsMask.FHCRC; // XXX: FTEXT
+      // XXX: FEXTRA
+
+      output[op++] = flg; // modification time
+
+      mtime = (Date.now ? Date.now() : +new Date()) / 1000 | 0;
+      output[op++] = mtime & 0xff;
+      output[op++] = mtime >>> 8 & 0xff;
+      output[op++] = mtime >>> 16 & 0xff;
+      output[op++] = mtime >>> 24 & 0xff; // extra flags
+
+      output[op++] = 0; // operating system
+
+      output[op++] = Zlib$1.Gzip.OperatingSystem.UNKNOWN; // extra
+
+      /* NOP */
+      // fname
+
+      if (this.flags['fname'] !== void 0) {
+        for (i = 0, il = filename.length; i < il; ++i) {
+          c = filename.charCodeAt(i);
+
+          if (c > 0xff) {
+            output[op++] = c >>> 8 & 0xff;
+          }
+
+          output[op++] = c & 0xff;
+        }
+
+        output[op++] = 0; // null termination
+      } // fcomment
+
+
+      if (this.flags['comment']) {
+        for (i = 0, il = comment.length; i < il; ++i) {
+          c = comment.charCodeAt(i);
+
+          if (c > 0xff) {
+            output[op++] = c >>> 8 & 0xff;
+          }
+
+          output[op++] = c & 0xff;
+        }
+
+        output[op++] = 0; // null termination
+      } // fhcrc
+
+
+      if (this.flags['fhcrc']) {
+        crc16 = Zlib$1.CRC32.calc(output, 0, op) & 0xffff;
+        output[op++] = crc16 & 0xff;
+        output[op++] = crc16 >>> 8 & 0xff;
+      } // add compress option
+
+
+      this.deflateOptions['outputBuffer'] = output;
+      this.deflateOptions['outputIndex'] = op; // compress
+
+      rawdeflate = new Zlib$1.RawDeflate(input, this.deflateOptions);
+      output = rawdeflate.compress();
+      op = rawdeflate.op; // expand buffer
+
+      {
+        if (op + 8 > output.buffer.byteLength) {
+          this.output = new Uint8Array(op + 8);
+          this.output.set(new Uint8Array(output.buffer));
+          output = this.output;
+        } else {
+          output = new Uint8Array(output.buffer);
+        }
+      } // crc32
+
+
+      crc32 = Zlib$1.CRC32.calc(input);
+      output[op++] = crc32 & 0xff;
+      output[op++] = crc32 >>> 8 & 0xff;
+      output[op++] = crc32 >>> 16 & 0xff;
+      output[op++] = crc32 >>> 24 & 0xff; // input size
+
+      il = input.length;
+      output[op++] = il & 0xff;
+      output[op++] = il >>> 8 & 0xff;
+      output[op++] = il >>> 16 & 0xff;
+      output[op++] = il >>> 24 & 0xff;
+      this.ip = ip;
+
+      if (op < output.length) {
+        this.output = output = output.subarray(0, op);
+      }
+
+      return output;
+    };
+    /** @enum {number} */
+
+
+    Zlib$1.Gzip.OperatingSystem = {
+      FAT: 0,
+      AMIGA: 1,
+      VMS: 2,
+      UNIX: 3,
+      VM_CMS: 4,
+      ATARI_TOS: 5,
+      HPFS: 6,
+      MACINTOSH: 7,
+      Z_SYSTEM: 8,
+      CP_M: 9,
+      TOPS_20: 10,
+      NTFS: 11,
+      QDOS: 12,
+      ACORN_RISCOS: 13,
+      UNKNOWN: 255
+    };
+    /** @enum {number} */
+
+    Zlib$1.Gzip.FlagsMask = {
+      FTEXT: 0x01,
+      FHCRC: 0x02,
+      FEXTRA: 0x04,
+      FNAME: 0x08,
+      FCOMMENT: 0x10
+    };
+    /**
+     * @fileoverview Heap Sort 実装. ハフマン符号化で使用する.
+     */
+
+    /**
+     * カスタムハフマン符号で使用するヒープ実装
+     * @param {number} length ヒープサイズ.
+     * @constructor
+     */
+
+    Zlib$1.Heap = function (length) {
+      this.buffer = new (Uint16Array )(length * 2);
+      this.length = 0;
+    };
+    /**
+     * 親ノードの index 取得
+     * @param {number} index 子ノードの index.
+     * @return {number} 親ノードの index.
+     *
+     */
+
+
+    Zlib$1.Heap.prototype.getParent = function (index) {
+      return ((index - 2) / 4 | 0) * 2;
+    };
+    /**
+     * 子ノードの index 取得
+     * @param {number} index 親ノードの index.
+     * @return {number} 子ノードの index.
+     */
+
+
+    Zlib$1.Heap.prototype.getChild = function (index) {
+      return 2 * index + 2;
+    };
+    /**
+     * Heap ã«å€¤ã‚’è¿½åŠ ã™ã‚‹
+     * @param {number} index キー index.
+     * @param {number} value 値.
+     * @return {number} 現在のヒープ長.
+     */
+
+
+    Zlib$1.Heap.prototype.push = function (index, value) {
+      var current,
+          parent,
+          heap = this.buffer,
+          swap;
+      current = this.length;
+      heap[this.length++] = value;
+      heap[this.length++] = index; // ルートノードにたどり着くまで入れ替えを試みる
+
+      while (current > 0) {
+        parent = this.getParent(current); // 親ノードと比較して親の方が小さければ入れ替える
+
+        if (heap[current] > heap[parent]) {
+          swap = heap[current];
+          heap[current] = heap[parent];
+          heap[parent] = swap;
+          swap = heap[current + 1];
+          heap[current + 1] = heap[parent + 1];
+          heap[parent + 1] = swap;
+          current = parent; // 入れ替えが必要なくなったらそこで抜ける
+        } else {
+          break;
+        }
+      }
+
+      return this.length;
+    };
+    /**
+     * Heapから一番大きい値を返す
+     * @return {{index: number, value: number, length: number}} {index: キーindex,
+     *     value: 値, length: ヒープ長} の Object.
+     */
+
+
+    Zlib$1.Heap.prototype.pop = function () {
+      var index,
+          value,
+          heap = this.buffer,
+          swap,
+          current,
+          parent;
+      value = heap[0];
+      index = heap[1]; // 後ろから値を取る
+
+      this.length -= 2;
+      heap[0] = heap[this.length];
+      heap[1] = heap[this.length + 1];
+      parent = 0; // ルートノードから下がっていく
+
+      while (true) {
+        current = this.getChild(parent); // 範囲チェック
+
+        if (current >= this.length) {
+          break;
+        } // 隣のノードと比較して、隣の方が値が大きければ隣を現在ノードとして選択
+
+
+        if (current + 2 < this.length && heap[current + 2] > heap[current]) {
+          current += 2;
+        } // è¦ªãƒŽãƒ¼ãƒ‰ã¨æ¯”è¼ƒã—ã¦è¦ªã®æ–¹ãŒå°ã•ã„å ´åˆã¯å…¥ã‚Œæ›¿ãˆã‚‹
+
+
+        if (heap[current] > heap[parent]) {
+          swap = heap[parent];
+          heap[parent] = heap[current];
+          heap[current] = swap;
+          swap = heap[parent + 1];
+          heap[parent + 1] = heap[current + 1];
+          heap[current + 1] = swap;
+        } else {
+          break;
+        }
+
+        parent = current;
+      }
+
+      return {
+        index: index,
+        value: value,
+        length: this.length
+      };
+    };
+    /* vim:set expandtab ts=2 sw=2 tw=80: */
+
+    /**
+     * @fileoverview Deflate (RFC1951) 符号化アルゴリズム実装.
+     */
+
+    /**
+     * Raw Deflate 実装
+     *
+     * @constructor
+     * @param {!(Array.<number>|Uint8Array)} input 符号化する対象のバッファ.
+     * @param {Object=} opt_params option parameters.
+     *
+     * typed array が使用可能なとき、outputBuffer が Array は自動的に Uint8Array に
+     * 変換されます.
+     * 別のオブジェクトになるため出力バッファを参照している変数などは
+     * 更新する必要があります.
+     */
+
+
+    Zlib$1.RawDeflate = function (input, opt_params) {
+      /** @type {Zlib.RawDeflate.CompressionType} */
+      this.compressionType = Zlib$1.RawDeflate.CompressionType.DYNAMIC;
+      /** @type {number} */
+
+      this.lazy = 0;
+      /** @type {!(Array.<number>|Uint32Array)} */
+
+      this.freqsLitLen;
+      /** @type {!(Array.<number>|Uint32Array)} */
+
+      this.freqsDist;
+      /** @type {!(Array.<number>|Uint8Array)} */
+
+      this.input = input instanceof Array ? new Uint8Array(input) : input;
+      /** @type {!(Array.<number>|Uint8Array)} output output buffer. */
+
+      this.output;
+      /** @type {number} pos output buffer position. */
+
+      this.op = 0; // option parameters
+
+      if (opt_params) {
+        if (opt_params['lazy']) {
+          this.lazy = opt_params['lazy'];
+        }
+
+        if (typeof opt_params['compressionType'] === 'number') {
+          this.compressionType = opt_params['compressionType'];
+        }
+
+        if (opt_params['outputBuffer']) {
+          this.output = opt_params['outputBuffer'] instanceof Array ? new Uint8Array(opt_params['outputBuffer']) : opt_params['outputBuffer'];
+        }
+
+        if (typeof opt_params['outputIndex'] === 'number') {
+          this.op = opt_params['outputIndex'];
+        }
+      }
+
+      if (!this.output) {
+        this.output = new (Uint8Array )(0x8000);
+      }
+    };
+    /**
+     * @enum {number}
+     */
+
+
+    Zlib$1.RawDeflate.CompressionType = {
+      NONE: 0,
+      FIXED: 1,
+      DYNAMIC: 2,
+      RESERVED: 3
+    };
+    /**
+     * LZ77 の最小マッチ長
+     * @const
+     * @type {number}
+     */
+
+    Zlib$1.RawDeflate.Lz77MinLength = 3;
+    /**
+     * LZ77 の最大マッチ長
+     * @const
+     * @type {number}
+     */
+
+    Zlib$1.RawDeflate.Lz77MaxLength = 258;
+    /**
+     * LZ77 のウィンドウサイズ
+     * @const
+     * @type {number}
+     */
+
+    Zlib$1.RawDeflate.WindowSize = 0x8000;
+    /**
+     * 最長の符号長
+     * @const
+     * @type {number}
+     */
+
+    Zlib$1.RawDeflate.MaxCodeLength = 16;
+    /**
+     * ハフマン符号の最大数値
+     * @const
+     * @type {number}
+     */
+
+    Zlib$1.RawDeflate.HUFMAX = 286;
+    /**
+     * 固定ハフマン符号の符号化テーブル
+     * @const
+     * @type {Array.<Array.<number, number>>}
+     */
+
+    Zlib$1.RawDeflate.FixedHuffmanTable = function () {
+      var table = [],
+          i;
+
+      for (i = 0; i < 288; i++) {
+        switch (true) {
+          case i <= 143:
+            table.push([i + 0x030, 8]);
+            break;
+
+          case i <= 255:
+            table.push([i - 144 + 0x190, 9]);
+            break;
+
+          case i <= 279:
+            table.push([i - 256 + 0x000, 7]);
+            break;
+
+          case i <= 287:
+            table.push([i - 280 + 0x0C0, 8]);
+            break;
+
+          default:
+            throw 'invalid literal: ' + i;
+        }
+      }
+
+      return table;
+    }();
+    /**
+     * DEFLATE ブロックの作成
+     * @return {!(Array.<number>|Uint8Array)} 圧縮済み byte array.
+     */
+
+
+    Zlib$1.RawDeflate.prototype.compress = function () {
+      /** @type {!(Array.<number>|Uint8Array)} */
+      var blockArray;
+      /** @type {number} */
+
+      var position;
+      /** @type {number} */
+
+      var length;
+      var input = this.input; // compression
+
+      switch (this.compressionType) {
+        case Zlib$1.RawDeflate.CompressionType.NONE:
+          // each 65535-Byte (length header: 16-bit)
+          for (position = 0, length = input.length; position < length;) {
+            blockArray = input.subarray(position, position + 0xffff) ;
+            position += blockArray.length;
+            this.makeNocompressBlock(blockArray, position === length);
+          }
+
+          break;
+
+        case Zlib$1.RawDeflate.CompressionType.FIXED:
+          this.output = this.makeFixedHuffmanBlock(input, true);
+          this.op = this.output.length;
+          break;
+
+        case Zlib$1.RawDeflate.CompressionType.DYNAMIC:
+          this.output = this.makeDynamicHuffmanBlock(input, true);
+          this.op = this.output.length;
+          break;
+
+        default:
+          throw 'invalid compression type';
+      }
+
+      return this.output;
+    };
+    /**
+     * 非圧縮ブロックの作成
+     * @param {!(Array.<number>|Uint8Array)} blockArray ブロックデータ byte array.
+     * @param {!boolean} isFinalBlock 最後のブロックならばtrue.
+     * @return {!(Array.<number>|Uint8Array)} 非圧縮ブロック byte array.
+     */
+
+
+    Zlib$1.RawDeflate.prototype.makeNocompressBlock = function (blockArray, isFinalBlock) {
+      /** @type {number} */
+      var bfinal;
+      /** @type {Zlib.RawDeflate.CompressionType} */
+
+      var btype;
+      /** @type {number} */
+
+      var len;
+      /** @type {number} */
+
+      var nlen;
+      var output = this.output;
+      var op = this.op; // expand buffer
+
+      {
+        output = new Uint8Array(this.output.buffer);
+
+        while (output.length <= op + blockArray.length + 5) {
+          output = new Uint8Array(output.length << 1);
+        }
+
+        output.set(this.output);
+      } // header
+
+
+      bfinal = isFinalBlock ? 1 : 0;
+      btype = Zlib$1.RawDeflate.CompressionType.NONE;
+      output[op++] = bfinal | btype << 1; // length
+
+      len = blockArray.length;
+      nlen = ~len + 0x10000 & 0xffff;
+      output[op++] = len & 0xff;
+      output[op++] = len >>> 8 & 0xff;
+      output[op++] = nlen & 0xff;
+      output[op++] = nlen >>> 8 & 0xff; // copy buffer
+
+      {
+        output.set(blockArray, op);
+        op += blockArray.length;
+        output = output.subarray(0, op);
+      }
+
+      this.op = op;
+      this.output = output;
+      return output;
+    };
+    /**
+     * 固定ハフマンブロックの作成
+     * @param {!(Array.<number>|Uint8Array)} blockArray ブロックデータ byte array.
+     * @param {!boolean} isFinalBlock 最後のブロックならばtrue.
+     * @return {!(Array.<number>|Uint8Array)} 固定ハフマン符号化ブロック byte array.
+     */
+
+
+    Zlib$1.RawDeflate.prototype.makeFixedHuffmanBlock = function (blockArray, isFinalBlock) {
+      /** @type {Zlib.BitStream} */
+      var stream = new Zlib$1.BitStream(new Uint8Array(this.output.buffer) , this.op);
+      /** @type {number} */
+
+      var bfinal;
+      /** @type {Zlib.RawDeflate.CompressionType} */
+
+      var btype;
+      /** @type {!(Array.<number>|Uint16Array)} */
+
+      var data; // header
+
+      bfinal = isFinalBlock ? 1 : 0;
+      btype = Zlib$1.RawDeflate.CompressionType.FIXED;
+      stream.writeBits(bfinal, 1, true);
+      stream.writeBits(btype, 2, true);
+      data = this.lz77(blockArray);
+      this.fixedHuffman(data, stream);
+      return stream.finish();
+    };
+    /**
+     * 動的ハフマンブロックの作成
+     * @param {!(Array.<number>|Uint8Array)} blockArray ブロックデータ byte array.
+     * @param {!boolean} isFinalBlock 最後のブロックならばtrue.
+     * @return {!(Array.<number>|Uint8Array)} 動的ハフマン符号ブロック byte array.
+     */
+
+
+    Zlib$1.RawDeflate.prototype.makeDynamicHuffmanBlock = function (blockArray, isFinalBlock) {
+      /** @type {Zlib.BitStream} */
+      var stream = new Zlib$1.BitStream(new Uint8Array(this.output.buffer) , this.op);
+      /** @type {number} */
+
+      var bfinal;
+      /** @type {Zlib.RawDeflate.CompressionType} */
+
+      var btype;
+      /** @type {!(Array.<number>|Uint16Array)} */
+
+      var data;
+      /** @type {number} */
+
+      var hlit;
+      /** @type {number} */
+
+      var hdist;
+      /** @type {number} */
+
+      var hclen;
+      /** @const @type {Array.<number>} */
+
+      var hclenOrder = [16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15];
+      /** @type {!(Array.<number>|Uint8Array)} */
+
+      var litLenLengths;
+      /** @type {!(Array.<number>|Uint16Array)} */
+
+      var litLenCodes;
+      /** @type {!(Array.<number>|Uint8Array)} */
+
+      var distLengths;
+      /** @type {!(Array.<number>|Uint16Array)} */
+
+      var distCodes;
+      /** @type {{
+       *   codes: !(Array.<number>|Uint32Array),
+       *   freqs: !(Array.<number>|Uint8Array)
+       * }} */
+
+      var treeSymbols;
+      /** @type {!(Array.<number>|Uint8Array)} */
+
+      var treeLengths;
+      /** @type {Array} */
+
+      var transLengths = new Array(19);
+      /** @type {!(Array.<number>|Uint16Array)} */
+
+      var treeCodes;
+      /** @type {number} */
+
+      var code;
+      /** @type {number} */
+
+      var bitlen;
+      /** @type {number} */
+
+      var i;
+      /** @type {number} */
+
+      var il; // header
+
+      bfinal = isFinalBlock ? 1 : 0;
+      btype = Zlib$1.RawDeflate.CompressionType.DYNAMIC;
+      stream.writeBits(bfinal, 1, true);
+      stream.writeBits(btype, 2, true);
+      data = this.lz77(blockArray); // リテラル・長さ, 距離のハフマン符号と符号長の算出
+
+      litLenLengths = this.getLengths_(this.freqsLitLen, 15);
+      litLenCodes = this.getCodesFromLengths_(litLenLengths);
+      distLengths = this.getLengths_(this.freqsDist, 7);
+      distCodes = this.getCodesFromLengths_(distLengths); // HLIT, HDIST の決定
+
+      for (hlit = 286; hlit > 257 && litLenLengths[hlit - 1] === 0; hlit--) {}
+
+      for (hdist = 30; hdist > 1 && distLengths[hdist - 1] === 0; hdist--) {} // HCLEN
+
+
+      treeSymbols = this.getTreeSymbols_(hlit, litLenLengths, hdist, distLengths);
+      treeLengths = this.getLengths_(treeSymbols.freqs, 7);
+
+      for (i = 0; i < 19; i++) {
+        transLengths[i] = treeLengths[hclenOrder[i]];
+      }
+
+      for (hclen = 19; hclen > 4 && transLengths[hclen - 1] === 0; hclen--) {}
+
+      treeCodes = this.getCodesFromLengths_(treeLengths); // 出力
+
+      stream.writeBits(hlit - 257, 5, true);
+      stream.writeBits(hdist - 1, 5, true);
+      stream.writeBits(hclen - 4, 4, true);
+
+      for (i = 0; i < hclen; i++) {
+        stream.writeBits(transLengths[i], 3, true);
+      } // ツリーの出力
+
+
+      for (i = 0, il = treeSymbols.codes.length; i < il; i++) {
+        code = treeSymbols.codes[i];
+        stream.writeBits(treeCodes[code], treeLengths[code], true); // extra bits
+
+        if (code >= 16) {
+          i++;
+
+          switch (code) {
+            case 16:
+              bitlen = 2;
+              break;
+
+            case 17:
+              bitlen = 3;
+              break;
+
+            case 18:
+              bitlen = 7;
+              break;
+
+            default:
+              throw 'invalid code: ' + code;
+          }
+
+          stream.writeBits(treeSymbols.codes[i], bitlen, true);
+        }
+      }
+
+      this.dynamicHuffman(data, [litLenCodes, litLenLengths], [distCodes, distLengths], stream);
+      return stream.finish();
+    };
+    /**
+     * 動的ハフマン符号化(カスタムハフマンテーブル)
+     * @param {!(Array.<number>|Uint16Array)} dataArray LZ77 符号化済み byte array.
+     * @param {!Zlib.BitStream} stream 書き込み用ビットストリーム.
+     * @return {!Zlib.BitStream} ハフマン符号化済みビットストリームオブジェクト.
+     */
+
+
+    Zlib$1.RawDeflate.prototype.dynamicHuffman = function (dataArray, litLen, dist, stream) {
+      /** @type {number} */
+      var index;
+      /** @type {number} */
+
+      var length;
+      /** @type {number} */
+
+      var literal;
+      /** @type {number} */
+
+      var code;
+      /** @type {number} */
+
+      var litLenCodes;
+      /** @type {number} */
+
+      var litLenLengths;
+      /** @type {number} */
+
+      var distCodes;
+      /** @type {number} */
+
+      var distLengths;
+      litLenCodes = litLen[0];
+      litLenLengths = litLen[1];
+      distCodes = dist[0];
+      distLengths = dist[1]; // 符号を BitStream に書き込んでいく
+
+      for (index = 0, length = dataArray.length; index < length; ++index) {
+        literal = dataArray[index]; // literal or length
+
+        stream.writeBits(litLenCodes[literal], litLenLengths[literal], true); // 長さ・距離符号
+
+        if (literal > 256) {
+          // length extra
+          stream.writeBits(dataArray[++index], dataArray[++index], true); // distance
+
+          code = dataArray[++index];
+          stream.writeBits(distCodes[code], distLengths[code], true); // distance extra
+
+          stream.writeBits(dataArray[++index], dataArray[++index], true); // 終端
+        } else if (literal === 256) {
+          break;
+        }
+      }
+
+      return stream;
+    };
+    /**
+     * 固定ハフマン符号化
+     * @param {!(Array.<number>|Uint16Array)} dataArray LZ77 符号化済み byte array.
+     * @param {!Zlib.BitStream} stream 書き込み用ビットストリーム.
+     * @return {!Zlib.BitStream} ハフマン符号化済みビットストリームオブジェクト.
+     */
+
+
+    Zlib$1.RawDeflate.prototype.fixedHuffman = function (dataArray, stream) {
+      /** @type {number} */
+      var index;
+      /** @type {number} */
+
+      var length;
+      /** @type {number} */
+
+      var literal; // 符号を BitStream に書き込んでいく
+
+      for (index = 0, length = dataArray.length; index < length; index++) {
+        literal = dataArray[index]; // 符号の書き込み
+
+        Zlib$1.BitStream.prototype.writeBits.apply(stream, Zlib$1.RawDeflate.FixedHuffmanTable[literal]); // 長さ・距離符号
+
+        if (literal > 0x100) {
+          // length extra
+          stream.writeBits(dataArray[++index], dataArray[++index], true); // distance
+
+          stream.writeBits(dataArray[++index], 5); // distance extra
+
+          stream.writeBits(dataArray[++index], dataArray[++index], true); // 終端
+        } else if (literal === 0x100) {
+          break;
+        }
+      }
+
+      return stream;
+    };
+    /**
+     * ãƒžãƒƒãƒæƒ…å ±
+     * @param {!number} length マッチした長さ.
+     * @param {!number} backwardDistance マッチ位置との距離.
+     * @constructor
+     */
+
+
+    Zlib$1.RawDeflate.Lz77Match = function (length, backwardDistance) {
+      /** @type {number} match length. */
+      this.length = length;
+      /** @type {number} backward distance. */
+
+      this.backwardDistance = backwardDistance;
+    };
+    /**
+     * 長さ符号テーブル.
+     * [コード, 拡張ビット, 拡張ビット長] の配列となっている.
+     * @const
+     * @type {!(Array.<number>|Uint32Array)}
+     */
+
+
+    Zlib$1.RawDeflate.Lz77Match.LengthCodeTable = function (table) {
+      return new Uint32Array(table) ;
+    }(function () {
+      /** @type {!Array} */
+      var table = [];
+      /** @type {number} */
+
+      var i;
+      /** @type {!Array.<number>} */
+
+      var c;
+
+      for (i = 3; i <= 258; i++) {
+        c = code(i);
+        table[i] = c[2] << 24 | c[1] << 16 | c[0];
+      }
+      /**
+       * @param {number} length lz77 length.
+       * @return {!Array.<number>} lz77 codes.
+       */
+
+
+      function code(length) {
+        switch (true) {
+          case length === 3:
+            return [257, length - 3, 0];
+
+          case length === 4:
+            return [258, length - 4, 0];
+
+          case length === 5:
+            return [259, length - 5, 0];
+
+          case length === 6:
+            return [260, length - 6, 0];
+
+          case length === 7:
+            return [261, length - 7, 0];
+
+          case length === 8:
+            return [262, length - 8, 0];
+
+          case length === 9:
+            return [263, length - 9, 0];
+
+          case length === 10:
+            return [264, length - 10, 0];
+
+          case length <= 12:
+            return [265, length - 11, 1];
+
+          case length <= 14:
+            return [266, length - 13, 1];
+
+          case length <= 16:
+            return [267, length - 15, 1];
+
+          case length <= 18:
+            return [268, length - 17, 1];
+
+          case length <= 22:
+            return [269, length - 19, 2];
+
+          case length <= 26:
+            return [270, length - 23, 2];
+
+          case length <= 30:
+            return [271, length - 27, 2];
+
+          case length <= 34:
+            return [272, length - 31, 2];
+
+          case length <= 42:
+            return [273, length - 35, 3];
+
+          case length <= 50:
+            return [274, length - 43, 3];
+
+          case length <= 58:
+            return [275, length - 51, 3];
+
+          case length <= 66:
+            return [276, length - 59, 3];
+
+          case length <= 82:
+            return [277, length - 67, 4];
+
+          case length <= 98:
+            return [278, length - 83, 4];
+
+          case length <= 114:
+            return [279, length - 99, 4];
+
+          case length <= 130:
+            return [280, length - 115, 4];
+
+          case length <= 162:
+            return [281, length - 131, 5];
+
+          case length <= 194:
+            return [282, length - 163, 5];
+
+          case length <= 226:
+            return [283, length - 195, 5];
+
+          case length <= 257:
+            return [284, length - 227, 5];
+
+          case length === 258:
+            return [285, length - 258, 0];
+
+          default:
+            throw 'invalid length: ' + length;
+        }
+      }
+
+      return table;
+    }());
+    /**
+     * 距離符号テーブル
+     * @param {!number} dist 距離.
+     * @return {!Array.<number>} コード、拡張ビット、拡張ビット長の配列.
+     * @private
+     */
+
+
+    Zlib$1.RawDeflate.Lz77Match.prototype.getDistanceCode_ = function (dist) {
+      /** @type {!Array.<number>} distance code table. */
+      var r;
+
+      switch (true) {
+        case dist === 1:
+          r = [0, dist - 1, 0];
+          break;
+
+        case dist === 2:
+          r = [1, dist - 2, 0];
+          break;
+
+        case dist === 3:
+          r = [2, dist - 3, 0];
+          break;
+
+        case dist === 4:
+          r = [3, dist - 4, 0];
+          break;
+
+        case dist <= 6:
+          r = [4, dist - 5, 1];
+          break;
+
+        case dist <= 8:
+          r = [5, dist - 7, 1];
+          break;
+
+        case dist <= 12:
+          r = [6, dist - 9, 2];
+          break;
+
+        case dist <= 16:
+          r = [7, dist - 13, 2];
+          break;
+
+        case dist <= 24:
+          r = [8, dist - 17, 3];
+          break;
+
+        case dist <= 32:
+          r = [9, dist - 25, 3];
+          break;
+
+        case dist <= 48:
+          r = [10, dist - 33, 4];
+          break;
+
+        case dist <= 64:
+          r = [11, dist - 49, 4];
+          break;
+
+        case dist <= 96:
+          r = [12, dist - 65, 5];
+          break;
+
+        case dist <= 128:
+          r = [13, dist - 97, 5];
+          break;
+
+        case dist <= 192:
+          r = [14, dist - 129, 6];
+          break;
+
+        case dist <= 256:
+          r = [15, dist - 193, 6];
+          break;
+
+        case dist <= 384:
+          r = [16, dist - 257, 7];
+          break;
+
+        case dist <= 512:
+          r = [17, dist - 385, 7];
+          break;
+
+        case dist <= 768:
+          r = [18, dist - 513, 8];
+          break;
+
+        case dist <= 1024:
+          r = [19, dist - 769, 8];
+          break;
+
+        case dist <= 1536:
+          r = [20, dist - 1025, 9];
+          break;
+
+        case dist <= 2048:
+          r = [21, dist - 1537, 9];
+          break;
+
+        case dist <= 3072:
+          r = [22, dist - 2049, 10];
+          break;
+
+        case dist <= 4096:
+          r = [23, dist - 3073, 10];
+          break;
+
+        case dist <= 6144:
+          r = [24, dist - 4097, 11];
+          break;
+
+        case dist <= 8192:
+          r = [25, dist - 6145, 11];
+          break;
+
+        case dist <= 12288:
+          r = [26, dist - 8193, 12];
+          break;
+
+        case dist <= 16384:
+          r = [27, dist - 12289, 12];
+          break;
+
+        case dist <= 24576:
+          r = [28, dist - 16385, 13];
+          break;
+
+        case dist <= 32768:
+          r = [29, dist - 24577, 13];
+          break;
+
+        default:
+          throw 'invalid distance';
+      }
+
+      return r;
+    };
+    /**
+     * ãƒžãƒƒãƒæƒ…å ±ã‚’ LZ77 符号化配列で返す.
+     * なお、ここでは以下の内部仕様で符号化している
+     * [ CODE, EXTRA-BIT-LEN, EXTRA, CODE, EXTRA-BIT-LEN, EXTRA ]
+     * @return {!Array.<number>} LZ77 符号化 byte array.
+     */
+
+
+    Zlib$1.RawDeflate.Lz77Match.prototype.toLz77Array = function () {
+      /** @type {number} */
+      var length = this.length;
+      /** @type {number} */
+
+      var dist = this.backwardDistance;
+      /** @type {Array} */
+
+      var codeArray = [];
+      /** @type {number} */
+
+      var pos = 0;
+      /** @type {!Array.<number>} */
+
+      var code; // length
+
+      code = Zlib$1.RawDeflate.Lz77Match.LengthCodeTable[length];
+      codeArray[pos++] = code & 0xffff;
+      codeArray[pos++] = code >> 16 & 0xff;
+      codeArray[pos++] = code >> 24; // distance
+
+      code = this.getDistanceCode_(dist);
+      codeArray[pos++] = code[0];
+      codeArray[pos++] = code[1];
+      codeArray[pos++] = code[2];
+      return codeArray;
+    };
+    /**
+     * LZ77 実装
+     * @param {!(Array.<number>|Uint8Array)} dataArray LZ77 符号化するバイト配列.
+     * @return {!(Array.<number>|Uint16Array)} LZ77 符号化した配列.
+     */
+
+
+    Zlib$1.RawDeflate.prototype.lz77 = function (dataArray) {
+      /** @type {number} input position */
+      var position;
+      /** @type {number} input length */
+
+      var length;
+      /** @type {number} loop counter */
+
+      var i;
+      /** @type {number} loop limiter */
+
+      var il;
+      /** @type {number} chained-hash-table key */
+
+      var matchKey;
+      /** @type {Object.<number, Array.<number>>} chained-hash-table */
+
+      var table = {};
+      /** @const @type {number} */
+
+      var windowSize = Zlib$1.RawDeflate.WindowSize;
+      /** @type {Array.<number>} match list */
+
+      var matchList;
+      /** @type {Zlib.RawDeflate.Lz77Match} longest match */
+
+      var longestMatch;
+      /** @type {Zlib.RawDeflate.Lz77Match} previous longest match */
+
+      var prevMatch;
+      /** @type {!(Array.<number>|Uint16Array)} lz77 buffer */
+
+      var lz77buf = new Uint16Array(dataArray.length * 2) ;
+      /** @type {number} lz77 output buffer pointer */
+
+      var pos = 0;
+      /** @type {number} lz77 skip length */
+
+      var skipLength = 0;
+      /** @type {!(Array.<number>|Uint32Array)} */
+
+      var freqsLitLen = new (Uint32Array )(286);
+      /** @type {!(Array.<number>|Uint32Array)} */
+
+      var freqsDist = new (Uint32Array )(30);
+      /** @type {number} */
+
+      var lazy = this.lazy;
+      /** @type {*} temporary variable */
+
+      var tmp; // 初期化
+
+      freqsLitLen[256] = 1; // EOB の最低出現回数は 1
+
+      /**
+       * マッチデータの書き込み
+       * @param {Zlib.RawDeflate.Lz77Match} match LZ77 Match data.
+       * @param {!number} offset スキップ開始位置(相対指定).
+       * @private
+       */
+
+      function writeMatch(match, offset) {
+        /** @type {Array.<number>} */
+        var lz77Array = match.toLz77Array();
+        /** @type {number} */
+
+        var i;
+        /** @type {number} */
+
+        var il;
+
+        for (i = 0, il = lz77Array.length; i < il; ++i) {
+          lz77buf[pos++] = lz77Array[i];
+        }
+
+        freqsLitLen[lz77Array[0]]++;
+        freqsDist[lz77Array[3]]++;
+        skipLength = match.length + offset - 1;
+        prevMatch = null;
+      } // LZ77 符号化
+
+
+      for (position = 0, length = dataArray.length; position < length; ++position) {
+        // ハッシュキーの作成
+        for (matchKey = 0, i = 0, il = Zlib$1.RawDeflate.Lz77MinLength; i < il; ++i) {
+          if (position + i === length) {
+            break;
+          }
+
+          matchKey = matchKey << 8 | dataArray[position + i];
+        } // テーブルが未定義だったら作成する
+
+
+        if (table[matchKey] === void 0) {
+          table[matchKey] = [];
+        }
+
+        matchList = table[matchKey]; // skip
+
+        if (skipLength-- > 0) {
+          matchList.push(position);
+          continue;
+        } // マッチテーブルの更新 (最大戻り距離を超えているものを削除する)
+
+
+        while (matchList.length > 0 && position - matchList[0] > windowSize) {
+          matchList.shift();
+        } // ãƒ‡ãƒ¼ã‚¿æœ«å°¾ã§ãƒžãƒƒãƒã—ã‚ˆã†ãŒãªã„å ´åˆã¯ãã®ã¾ã¾æµã—ã“ã‚€
+
+
+        if (position + Zlib$1.RawDeflate.Lz77MinLength >= length) {
+          if (prevMatch) {
+            writeMatch(prevMatch, -1);
+          }
+
+          for (i = 0, il = length - position; i < il; ++i) {
+            tmp = dataArray[position + i];
+            lz77buf[pos++] = tmp;
+            ++freqsLitLen[tmp];
+          }
+
+          break;
+        } // マッチ候補から最長のものを探す
+
+
+        if (matchList.length > 0) {
+          longestMatch = this.searchLongestMatch_(dataArray, position, matchList);
+
+          if (prevMatch) {
+            // 現在のマッチの方が前回のマッチよりも長い
+            if (prevMatch.length < longestMatch.length) {
+              // write previous literal
+              tmp = dataArray[position - 1];
+              lz77buf[pos++] = tmp;
+              ++freqsLitLen[tmp]; // write current match
+
+              writeMatch(longestMatch, 0);
+            } else {
+              // write previous match
+              writeMatch(prevMatch, -1);
+            }
+          } else if (longestMatch.length < lazy) {
+            prevMatch = longestMatch;
+          } else {
+            writeMatch(longestMatch, 0);
+          } // 前回マッチしていて今回マッチがなかったら前回のを採用
+
+        } else if (prevMatch) {
+          writeMatch(prevMatch, -1);
+        } else {
+          tmp = dataArray[position];
+          lz77buf[pos++] = tmp;
+          ++freqsLitLen[tmp];
+        }
+
+        matchList.push(position); // マッチテーブルに現在の位置を保存
+      } // 終端処理
+
+
+      lz77buf[pos++] = 256;
+      freqsLitLen[256]++;
+      this.freqsLitLen = freqsLitLen;
+      this.freqsDist = freqsDist;
+      return lz77buf.subarray(0, pos) ;
+    };
+    /**
+     * マッチした候補の中から最長一致を探す
+     * @param {!Object} data plain data byte array.
+     * @param {!number} position plain data byte array position.
+     * @param {!Array.<number>} matchList 候補となる位置の配列.
+     * @return {!Zlib.RawDeflate.Lz77Match} 最長かつ最短距離のマッチオブジェクト.
+     * @private
+     */
+
+
+    Zlib$1.RawDeflate.prototype.searchLongestMatch_ = function (data, position, matchList) {
+      var match,
+          currentMatch,
+          matchMax = 0,
+          matchLength,
+          i,
+          j,
+          l,
+          dl = data.length; // 候補を後ろから 1 つずつ絞り込んでゆく
+
+      permatch: for (i = 0, l = matchList.length; i < l; i++) {
+        match = matchList[l - i - 1];
+        matchLength = Zlib$1.RawDeflate.Lz77MinLength; // 前回までの最長一致を末尾から一致検索する
+
+        if (matchMax > Zlib$1.RawDeflate.Lz77MinLength) {
+          for (j = matchMax; j > Zlib$1.RawDeflate.Lz77MinLength; j--) {
+            if (data[match + j - 1] !== data[position + j - 1]) {
+              continue permatch;
+            }
+          }
+
+          matchLength = matchMax;
+        } // 最長一致探索
+
+
+        while (matchLength < Zlib$1.RawDeflate.Lz77MaxLength && position + matchLength < dl && data[match + matchLength] === data[position + matchLength]) {
+          ++matchLength;
+        } // ãƒžãƒƒãƒé•·ãŒåŒã˜å ´åˆã¯å¾Œæ–¹ã‚’å„ªå…ˆ
+
+
+        if (matchLength > matchMax) {
+          currentMatch = match;
+          matchMax = matchLength;
+        } // 最長が確定したら後の処理は省略
+
+
+        if (matchLength === Zlib$1.RawDeflate.Lz77MaxLength) {
+          break;
+        }
+      }
+
+      return new Zlib$1.RawDeflate.Lz77Match(matchMax, position - currentMatch);
+    };
+    /**
+     * Tree-Transmit Symbols の算出
+     * reference: PuTTY Deflate implementation
+     * @param {number} hlit HLIT.
+     * @param {!(Array.<number>|Uint8Array)} litlenLengths リテラルと長さ符号の符号長配列.
+     * @param {number} hdist HDIST.
+     * @param {!(Array.<number>|Uint8Array)} distLengths 距離符号の符号長配列.
+     * @return {{
+     *   codes: !(Array.<number>|Uint32Array),
+     *   freqs: !(Array.<number>|Uint8Array)
+     * }} Tree-Transmit Symbols.
+     */
+
+
+    Zlib$1.RawDeflate.prototype.getTreeSymbols_ = function (hlit, litlenLengths, hdist, distLengths) {
+      var src = new (Uint32Array )(hlit + hdist),
+          i,
+          j,
+          runLength,
+          l,
+          result = new (Uint32Array )(286 + 30),
+          nResult,
+          rpt,
+          freqs = new (Uint8Array )(19);
+      j = 0;
+
+      for (i = 0; i < hlit; i++) {
+        src[j++] = litlenLengths[i];
+      }
+
+      for (i = 0; i < hdist; i++) {
+        src[j++] = distLengths[i];
+      } // 初期化
+
+
+      nResult = 0;
+
+      for (i = 0, l = src.length; i < l; i += j) {
+        // Run Length Encoding
+        for (j = 1; i + j < l && src[i + j] === src[i]; ++j) {}
+
+        runLength = j;
+
+        if (src[i] === 0) {
+          // 0 の繰り返しが 3 回未満ならばそのまま
+          if (runLength < 3) {
+            while (runLength-- > 0) {
+              result[nResult++] = 0;
+              freqs[0]++;
+            }
+          } else {
+            while (runLength > 0) {
+              // 繰り返しは最大 138 までなので切り詰める
+              rpt = runLength < 138 ? runLength : 138;
+
+              if (rpt > runLength - 3 && rpt < runLength) {
+                rpt = runLength - 3;
+              } // 3-10 回 -> 17
+
+
+              if (rpt <= 10) {
+                result[nResult++] = 17;
+                result[nResult++] = rpt - 3;
+                freqs[17]++; // 11-138 回 -> 18
+              } else {
+                result[nResult++] = 18;
+                result[nResult++] = rpt - 11;
+                freqs[18]++;
+              }
+
+              runLength -= rpt;
+            }
+          }
+        } else {
+          result[nResult++] = src[i];
+          freqs[src[i]]++;
+          runLength--; // 繰り返し回数が3回未満ならばランレングス符号は要らない
+
+          if (runLength < 3) {
+            while (runLength-- > 0) {
+              result[nResult++] = src[i];
+              freqs[src[i]]++;
+            } // 3 回以上ならばランレングス符号化
+
+          } else {
+            while (runLength > 0) {
+              // runLengthを 3-6 で分割
+              rpt = runLength < 6 ? runLength : 6;
+
+              if (rpt > runLength - 3 && rpt < runLength) {
+                rpt = runLength - 3;
+              }
+
+              result[nResult++] = 16;
+              result[nResult++] = rpt - 3;
+              freqs[16]++;
+              runLength -= rpt;
+            }
+          }
+        }
+      }
+
+      return {
+        codes: result.subarray(0, nResult) ,
+        freqs: freqs
+      };
+    };
+    /**
+     * ハフマン符号の長さを取得する
+     * @param {!(Array.<number>|Uint8Array|Uint32Array)} freqs 出現カウント.
+     * @param {number} limit 符号長の制限.
+     * @return {!(Array.<number>|Uint8Array)} 符号長配列.
+     * @private
+     */
+
+
+    Zlib$1.RawDeflate.prototype.getLengths_ = function (freqs, limit) {
+      /** @type {number} */
+      var nSymbols = freqs.length;
+      /** @type {Zlib.Heap} */
+
+      var heap = new Zlib$1.Heap(2 * Zlib$1.RawDeflate.HUFMAX);
+      /** @type {!(Array.<number>|Uint8Array)} */
+
+      var length = new (Uint8Array )(nSymbols);
+      /** @type {Array} */
+
+      var nodes;
+      /** @type {!(Array.<number>|Uint32Array)} */
+
+      var values;
+      /** @type {!(Array.<number>|Uint8Array)} */
+
+      var codeLength;
+      /** @type {number} */
+
+      var i;
+      /** @type {number} */
+
+      var il; // 配列の初期化
+
+
+      for (i = 0; i < nSymbols; ++i) {
+        if (freqs[i] > 0) {
+          heap.push(i, freqs[i]);
+        }
+      }
+
+      nodes = new Array(heap.length / 2);
+      values = new (Uint32Array )(heap.length / 2); // 非 0 ã®è¦ç´ ãŒä¸€ã¤ã ã‘ã ã£ãŸå ´åˆã¯ã€ãã®ã‚·ãƒ³ãƒœãƒ«ã«ç¬¦å·é•· 1 を割り当てて終了
+
+      if (nodes.length === 1) {
+        length[heap.pop().index] = 1;
+        return length;
+      } // Reverse Package Merge Algorithm による Canonical Huffman Code の符号長決定
+
+
+      for (i = 0, il = heap.length / 2; i < il; ++i) {
+        nodes[i] = heap.pop();
+        values[i] = nodes[i].value;
+      }
+
+      codeLength = this.reversePackageMerge_(values, values.length, limit);
+
+      for (i = 0, il = nodes.length; i < il; ++i) {
+        length[nodes[i].index] = codeLength[i];
+      }
+
+      return length;
+    };
+    /**
+     * Reverse Package Merge Algorithm.
+     * @param {!(Array.<number>|Uint32Array)} freqs sorted probability.
+     * @param {number} symbols number of symbols.
+     * @param {number} limit code length limit.
+     * @return {!(Array.<number>|Uint8Array)} code lengths.
+     */
+
+
+    Zlib$1.RawDeflate.prototype.reversePackageMerge_ = function (freqs, symbols, limit) {
+      /** @type {!(Array.<number>|Uint16Array)} */
+      var minimumCost = new (Uint16Array )(limit);
+      /** @type {!(Array.<number>|Uint8Array)} */
+
+      var flag = new (Uint8Array )(limit);
+      /** @type {!(Array.<number>|Uint8Array)} */
+
+      var codeLength = new (Uint8Array )(symbols);
+      /** @type {Array} */
+
+      var value = new Array(limit);
+      /** @type {Array} */
+
+      var type = new Array(limit);
+      /** @type {Array.<number>} */
+
+      var currentPosition = new Array(limit);
+      /** @type {number} */
+
+      var excess = (1 << limit) - symbols;
+      /** @type {number} */
+
+      var half = 1 << limit - 1;
+      /** @type {number} */
+
+      var i;
+      /** @type {number} */
+
+      var j;
+      /** @type {number} */
+
+      var t;
+      /** @type {number} */
+
+      var weight;
+      /** @type {number} */
+
+      var next;
+      /**
+       * @param {number} j
+       */
+
+      function takePackage(j) {
+        /** @type {number} */
+        var x = type[j][currentPosition[j]];
+
+        if (x === symbols) {
+          takePackage(j + 1);
+          takePackage(j + 1);
+        } else {
+          --codeLength[x];
+        }
+
+        ++currentPosition[j];
+      }
+
+      minimumCost[limit - 1] = symbols;
+
+      for (j = 0; j < limit; ++j) {
+        if (excess < half) {
+          flag[j] = 0;
+        } else {
+          flag[j] = 1;
+          excess -= half;
+        }
+
+        excess <<= 1;
+        minimumCost[limit - 2 - j] = (minimumCost[limit - 1 - j] / 2 | 0) + symbols;
+      }
+
+      minimumCost[0] = flag[0];
+      value[0] = new Array(minimumCost[0]);
+      type[0] = new Array(minimumCost[0]);
+
+      for (j = 1; j < limit; ++j) {
+        if (minimumCost[j] > 2 * minimumCost[j - 1] + flag[j]) {
+          minimumCost[j] = 2 * minimumCost[j - 1] + flag[j];
+        }
+
+        value[j] = new Array(minimumCost[j]);
+        type[j] = new Array(minimumCost[j]);
+      }
+
+      for (i = 0; i < symbols; ++i) {
+        codeLength[i] = limit;
+      }
+
+      for (t = 0; t < minimumCost[limit - 1]; ++t) {
+        value[limit - 1][t] = freqs[t];
+        type[limit - 1][t] = t;
+      }
+
+      for (i = 0; i < limit; ++i) {
+        currentPosition[i] = 0;
+      }
+
+      if (flag[limit - 1] === 1) {
+        --codeLength[0];
+        ++currentPosition[limit - 1];
+      }
+
+      for (j = limit - 2; j >= 0; --j) {
+        i = 0;
+        weight = 0;
+        next = currentPosition[j + 1];
+
+        for (t = 0; t < minimumCost[j]; t++) {
+          weight = value[j + 1][next] + value[j + 1][next + 1];
+
+          if (weight > freqs[i]) {
+            value[j][t] = weight;
+            type[j][t] = symbols;
+            next += 2;
+          } else {
+            value[j][t] = freqs[i];
+            type[j][t] = i;
+            ++i;
+          }
+        }
+
+        currentPosition[j] = 0;
+
+        if (flag[j] === 1) {
+          takePackage(j);
+        }
+      }
+
+      return codeLength;
+    };
+    /**
+     * 符号長配列からハフマン符号を取得する
+     * reference: PuTTY Deflate implementation
+     * @param {!(Array.<number>|Uint8Array)} lengths 符号長配列.
+     * @return {!(Array.<number>|Uint16Array)} ハフマン符号配列.
+     * @private
+     */
+
+
+    Zlib$1.RawDeflate.prototype.getCodesFromLengths_ = function (lengths) {
+      var codes = new (Uint16Array )(lengths.length),
+          count = [],
+          startCode = [],
+          code = 0,
+          i,
+          il,
+          j,
+          m; // Count the codes of each length.
+
+      for (i = 0, il = lengths.length; i < il; i++) {
+        count[lengths[i]] = (count[lengths[i]] | 0) + 1;
+      } // Determine the starting code for each length block.
+
+
+      for (i = 1, il = Zlib$1.RawDeflate.MaxCodeLength; i <= il; i++) {
+        startCode[i] = code;
+        code += count[i] | 0;
+        code <<= 1;
+      } // Determine the code for each symbol. Mirrored, of course.
+
+
+      for (i = 0, il = lengths.length; i < il; i++) {
+        code = startCode[lengths[i]];
+        startCode[lengths[i]] += 1;
+        codes[i] = 0;
+
+        for (j = 0, m = lengths[i]; j < m; j++) {
+          codes[i] = codes[i] << 1 | code & 1;
+          code >>>= 1;
+        }
+      }
+
+      return codes;
+    };
+    /**
+     * @param {!(Array.<number>|Uint8Array)} input input buffer.
+     * @param {Object=} opt_params options.
+     * @constructor
+     */
+
+
+    Zlib$1.Unzip = function (input, opt_params) {
+      opt_params = opt_params || {};
+      /** @type {!(Array.<number>|Uint8Array)} */
+
+      this.input = input instanceof Array ? new Uint8Array(input) : input;
+      /** @type {number} */
+
+      this.ip = 0;
+      /** @type {number} */
+
+      this.eocdrOffset;
+      /** @type {number} */
+
+      this.numberOfThisDisk;
+      /** @type {number} */
+
+      this.startDisk;
+      /** @type {number} */
+
+      this.totalEntriesThisDisk;
+      /** @type {number} */
+
+      this.totalEntries;
+      /** @type {number} */
+
+      this.centralDirectorySize;
+      /** @type {number} */
+
+      this.centralDirectoryOffset;
+      /** @type {number} */
+
+      this.commentLength;
+      /** @type {(Array.<number>|Uint8Array)} */
+
+      this.comment;
+      /** @type {Array.<Zlib.Unzip.FileHeader>} */
+
+      this.fileHeaderList;
+      /** @type {Object.<string, number>} */
+
+      this.filenameToIndex;
+      /** @type {boolean} */
+
+      this.verify = opt_params['verify'] || false;
+      /** @type {(Array.<number>|Uint8Array)} */
+
+      this.password = opt_params['password'];
+    };
+
+    Zlib$1.Unzip.CompressionMethod = Zlib$1.Zip.CompressionMethod;
+    /**
+     * @type {Array.<number>}
+     * @const
+     */
+
+    Zlib$1.Unzip.FileHeaderSignature = Zlib$1.Zip.FileHeaderSignature;
+    /**
+     * @type {Array.<number>}
+     * @const
+     */
+
+    Zlib$1.Unzip.LocalFileHeaderSignature = Zlib$1.Zip.LocalFileHeaderSignature;
+    /**
+     * @type {Array.<number>}
+     * @const
+     */
+
+    Zlib$1.Unzip.CentralDirectorySignature = Zlib$1.Zip.CentralDirectorySignature;
+    /**
+     * @param {!(Array.<number>|Uint8Array)} input input buffer.
+     * @param {number} ip input position.
+     * @constructor
+     */
+
+    Zlib$1.Unzip.FileHeader = function (input, ip) {
+      /** @type {!(Array.<number>|Uint8Array)} */
+      this.input = input;
+      /** @type {number} */
+
+      this.offset = ip;
+      /** @type {number} */
+
+      this.length;
+      /** @type {number} */
+
+      this.version;
+      /** @type {number} */
+
+      this.os;
+      /** @type {number} */
+
+      this.needVersion;
+      /** @type {number} */
+
+      this.flags;
+      /** @type {number} */
+
+      this.compression;
+      /** @type {number} */
+
+      this.time;
+      /** @type {number} */
+
+      this.date;
+      /** @type {number} */
+
+      this.crc32;
+      /** @type {number} */
+
+      this.compressedSize;
+      /** @type {number} */
+
+      this.plainSize;
+      /** @type {number} */
+
+      this.fileNameLength;
+      /** @type {number} */
+
+      this.extraFieldLength;
+      /** @type {number} */
+
+      this.fileCommentLength;
+      /** @type {number} */
+
+      this.diskNumberStart;
+      /** @type {number} */
+
+      this.internalFileAttributes;
+      /** @type {number} */
+
+      this.externalFileAttributes;
+      /** @type {number} */
+
+      this.relativeOffset;
+      /** @type {string} */
+
+      this.filename;
+      /** @type {!(Array.<number>|Uint8Array)} */
+
+      this.extraField;
+      /** @type {!(Array.<number>|Uint8Array)} */
+
+      this.comment;
+    };
+
+    Zlib$1.Unzip.FileHeader.prototype.parse = function () {
+      /** @type {!(Array.<number>|Uint8Array)} */
+      var input = this.input;
+      /** @type {number} */
+
+      var ip = this.offset; // central file header signature
+
+      if (input[ip++] !== Zlib$1.Unzip.FileHeaderSignature[0] || input[ip++] !== Zlib$1.Unzip.FileHeaderSignature[1] || input[ip++] !== Zlib$1.Unzip.FileHeaderSignature[2] || input[ip++] !== Zlib$1.Unzip.FileHeaderSignature[3]) {
+        throw new Error('invalid file header signature');
+      } // version made by
+
+
+      this.version = input[ip++];
+      this.os = input[ip++]; // version needed to extract
+
+      this.needVersion = input[ip++] | input[ip++] << 8; // general purpose bit flag
+
+      this.flags = input[ip++] | input[ip++] << 8; // compression method
+
+      this.compression = input[ip++] | input[ip++] << 8; // last mod file time
+
+      this.time = input[ip++] | input[ip++] << 8; //last mod file date
+
+      this.date = input[ip++] | input[ip++] << 8; // crc-32
+
+      this.crc32 = (input[ip++] | input[ip++] << 8 | input[ip++] << 16 | input[ip++] << 24) >>> 0; // compressed size
+
+      this.compressedSize = (input[ip++] | input[ip++] << 8 | input[ip++] << 16 | input[ip++] << 24) >>> 0; // uncompressed size
+
+      this.plainSize = (input[ip++] | input[ip++] << 8 | input[ip++] << 16 | input[ip++] << 24) >>> 0; // file name length
+
+      this.fileNameLength = input[ip++] | input[ip++] << 8; // extra field length
+
+      this.extraFieldLength = input[ip++] | input[ip++] << 8; // file comment length
+
+      this.fileCommentLength = input[ip++] | input[ip++] << 8; // disk number start
+
+      this.diskNumberStart = input[ip++] | input[ip++] << 8; // internal file attributes
+
+      this.internalFileAttributes = input[ip++] | input[ip++] << 8; // external file attributes
+
+      this.externalFileAttributes = input[ip++] | input[ip++] << 8 | input[ip++] << 16 | input[ip++] << 24; // relative offset of local header
+
+      this.relativeOffset = (input[ip++] | input[ip++] << 8 | input[ip++] << 16 | input[ip++] << 24) >>> 0; // file name
+
+      this.filename = String.fromCharCode.apply(null, input.subarray(ip, ip += this.fileNameLength) ); // extra field
+
+      this.extraField = input.subarray(ip, ip += this.extraFieldLength) ; // file comment
+
+      this.comment = input.subarray(ip, ip + this.fileCommentLength) ;
+      this.length = ip - this.offset;
+    };
+    /**
+     * @param {!(Array.<number>|Uint8Array)} input input buffer.
+     * @param {number} ip input position.
+     * @constructor
+     */
+
+
+    Zlib$1.Unzip.LocalFileHeader = function (input, ip) {
+      /** @type {!(Array.<number>|Uint8Array)} */
+      this.input = input;
+      /** @type {number} */
+
+      this.offset = ip;
+      /** @type {number} */
+
+      this.length;
+      /** @type {number} */
+
+      this.needVersion;
+      /** @type {number} */
+
+      this.flags;
+      /** @type {number} */
+
+      this.compression;
+      /** @type {number} */
+
+      this.time;
+      /** @type {number} */
+
+      this.date;
+      /** @type {number} */
+
+      this.crc32;
+      /** @type {number} */
+
+      this.compressedSize;
+      /** @type {number} */
+
+      this.plainSize;
+      /** @type {number} */
+
+      this.fileNameLength;
+      /** @type {number} */
+
+      this.extraFieldLength;
+      /** @type {string} */
+
+      this.filename;
+      /** @type {!(Array.<number>|Uint8Array)} */
+
+      this.extraField;
+    };
+
+    Zlib$1.Unzip.LocalFileHeader.Flags = Zlib$1.Zip.Flags;
+
+    Zlib$1.Unzip.LocalFileHeader.prototype.parse = function () {
+      /** @type {!(Array.<number>|Uint8Array)} */
+      var input = this.input;
+      /** @type {number} */
+
+      var ip = this.offset; // local file header signature
+
+      if (input[ip++] !== Zlib$1.Unzip.LocalFileHeaderSignature[0] || input[ip++] !== Zlib$1.Unzip.LocalFileHeaderSignature[1] || input[ip++] !== Zlib$1.Unzip.LocalFileHeaderSignature[2] || input[ip++] !== Zlib$1.Unzip.LocalFileHeaderSignature[3]) {
+        throw new Error('invalid local file header signature');
+      } // version needed to extract
+
+
+      this.needVersion = input[ip++] | input[ip++] << 8; // general purpose bit flag
+
+      this.flags = input[ip++] | input[ip++] << 8; // compression method
+
+      this.compression = input[ip++] | input[ip++] << 8; // last mod file time
+
+      this.time = input[ip++] | input[ip++] << 8; //last mod file date
+
+      this.date = input[ip++] | input[ip++] << 8; // crc-32
+
+      this.crc32 = (input[ip++] | input[ip++] << 8 | input[ip++] << 16 | input[ip++] << 24) >>> 0; // compressed size
+
+      this.compressedSize = (input[ip++] | input[ip++] << 8 | input[ip++] << 16 | input[ip++] << 24) >>> 0; // uncompressed size
+
+      this.plainSize = (input[ip++] | input[ip++] << 8 | input[ip++] << 16 | input[ip++] << 24) >>> 0; // file name length
+
+      this.fileNameLength = input[ip++] | input[ip++] << 8; // extra field length
+
+      this.extraFieldLength = input[ip++] | input[ip++] << 8; // file name
+
+      this.filename = String.fromCharCode.apply(null, input.subarray(ip, ip += this.fileNameLength) ); // extra field
+
+      this.extraField = input.subarray(ip, ip += this.extraFieldLength) ;
+      this.length = ip - this.offset;
+    };
+
+    Zlib$1.Unzip.prototype.searchEndOfCentralDirectoryRecord = function () {
+      /** @type {!(Array.<number>|Uint8Array)} */
+      var input = this.input;
+      /** @type {number} */
+
+      var ip;
+
+      for (ip = input.length - 12; ip > 0; --ip) {
+        if (input[ip] === Zlib$1.Unzip.CentralDirectorySignature[0] && input[ip + 1] === Zlib$1.Unzip.CentralDirectorySignature[1] && input[ip + 2] === Zlib$1.Unzip.CentralDirectorySignature[2] && input[ip + 3] === Zlib$1.Unzip.CentralDirectorySignature[3]) {
+          this.eocdrOffset = ip;
+          return;
+        }
+      }
+
+      throw new Error('End of Central Directory Record not found');
+    };
+
+    Zlib$1.Unzip.prototype.parseEndOfCentralDirectoryRecord = function () {
+      /** @type {!(Array.<number>|Uint8Array)} */
+      var input = this.input;
+      /** @type {number} */
+
+      var ip;
+
+      if (!this.eocdrOffset) {
+        this.searchEndOfCentralDirectoryRecord();
+      }
+
+      ip = this.eocdrOffset; // signature
+
+      if (input[ip++] !== Zlib$1.Unzip.CentralDirectorySignature[0] || input[ip++] !== Zlib$1.Unzip.CentralDirectorySignature[1] || input[ip++] !== Zlib$1.Unzip.CentralDirectorySignature[2] || input[ip++] !== Zlib$1.Unzip.CentralDirectorySignature[3]) {
+        throw new Error('invalid signature');
+      } // number of this disk
+
+
+      this.numberOfThisDisk = input[ip++] | input[ip++] << 8; // number of the disk with the start of the central directory
+
+      this.startDisk = input[ip++] | input[ip++] << 8; // total number of entries in the central directory on this disk
+
+      this.totalEntriesThisDisk = input[ip++] | input[ip++] << 8; // total number of entries in the central directory
+
+      this.totalEntries = input[ip++] | input[ip++] << 8; // size of the central directory
+
+      this.centralDirectorySize = (input[ip++] | input[ip++] << 8 | input[ip++] << 16 | input[ip++] << 24) >>> 0; // offset of start of central directory with respect to the starting disk number
+
+      this.centralDirectoryOffset = (input[ip++] | input[ip++] << 8 | input[ip++] << 16 | input[ip++] << 24) >>> 0; // .ZIP file comment length
+
+      this.commentLength = input[ip++] | input[ip++] << 8; // .ZIP file comment
+
+      this.comment = input.subarray(ip, ip + this.commentLength) ;
+    };
+
+    Zlib$1.Unzip.prototype.parseFileHeader = function () {
+      /** @type {Array.<Zlib.Unzip.FileHeader>} */
+      var filelist = [];
+      /** @type {Object.<string, number>} */
+
+      var filetable = {};
+      /** @type {number} */
+
+      var ip;
+      /** @type {Zlib.Unzip.FileHeader} */
+
+      var fileHeader;
+      /*: @type {number} */
+
+      var i;
+      /*: @type {number} */
+
+      var il;
+
+      if (this.fileHeaderList) {
+        return;
+      }
+
+      if (this.centralDirectoryOffset === void 0) {
+        this.parseEndOfCentralDirectoryRecord();
+      }
+
+      ip = this.centralDirectoryOffset;
+
+      for (i = 0, il = this.totalEntries; i < il; ++i) {
+        fileHeader = new Zlib$1.Unzip.FileHeader(this.input, ip);
+        fileHeader.parse();
+        ip += fileHeader.length;
+        filelist[i] = fileHeader;
+        filetable[fileHeader.filename] = i;
+      }
+
+      if (this.centralDirectorySize < ip - this.centralDirectoryOffset) {
+        throw new Error('invalid file header size');
+      }
+
+      this.fileHeaderList = filelist;
+      this.filenameToIndex = filetable;
+    };
+    /**
+     * @param {number} index file header index.
+     * @param {Object=} opt_params
+     * @return {!(Array.<number>|Uint8Array)} file data.
+     */
+
+
+    Zlib$1.Unzip.prototype.getFileData = function (index, opt_params) {
+      opt_params = opt_params || {};
+      /** @type {!(Array.<number>|Uint8Array)} */
+
+      var input = this.input;
+      /** @type {Array.<Zlib.Unzip.FileHeader>} */
+
+      var fileHeaderList = this.fileHeaderList;
+      /** @type {Zlib.Unzip.LocalFileHeader} */
+
+      var localFileHeader;
+      /** @type {number} */
+
+      var offset;
+      /** @type {number} */
+
+      var length;
+      /** @type {!(Array.<number>|Uint8Array)} */
+
+      var buffer;
+      /** @type {number} */
+
+      var crc32;
+      /** @type {Array.<number>|Uint32Array|Object} */
+
+      var key;
+      /** @type {number} */
+
+      var i;
+      /** @type {number} */
+
+      var il;
+
+      if (!fileHeaderList) {
+        this.parseFileHeader();
+      }
+
+      if (fileHeaderList[index] === void 0) {
+        throw new Error('wrong index');
+      }
+
+      offset = fileHeaderList[index].relativeOffset;
+      localFileHeader = new Zlib$1.Unzip.LocalFileHeader(this.input, offset);
+      localFileHeader.parse();
+      offset += localFileHeader.length;
+      length = localFileHeader.compressedSize; // decryption
+
+      if ((localFileHeader.flags & Zlib$1.Unzip.LocalFileHeader.Flags.ENCRYPT) !== 0) {
+        if (!(opt_params['password'] || this.password)) {
+          throw new Error('please set password');
+        }
+
+        key = this.createDecryptionKey(opt_params['password'] || this.password); // encryption header
+
+        for (i = offset, il = offset + 12; i < il; ++i) {
+          this.decode(key, input[i]);
+        }
+
+        offset += 12;
+        length -= 12; // decryption
+
+        for (i = offset, il = offset + length; i < il; ++i) {
+          input[i] = this.decode(key, input[i]);
+        }
+      }
+
+      switch (localFileHeader.compression) {
+        case Zlib$1.Unzip.CompressionMethod.STORE:
+          buffer = this.input.subarray(offset, offset + length) ;
+          break;
+
+        case Zlib$1.Unzip.CompressionMethod.DEFLATE:
+          buffer = new Zlib$1.RawInflate(this.input, {
+            'index': offset,
+            'bufferSize': localFileHeader.plainSize
+          }).decompress();
+          break;
+
+        default:
+          throw new Error('unknown compression type');
+      }
+
+      if (this.verify) {
+        crc32 = Zlib$1.CRC32.calc(buffer);
+
+        if (localFileHeader.crc32 !== crc32) {
+          throw new Error('wrong crc: file=0x' + localFileHeader.crc32.toString(16) + ', data=0x' + crc32.toString(16));
+        }
+      }
+
+      return buffer;
+    };
+    /**
+     * @return {Array.<string>}
+     */
+
+
+    Zlib$1.Unzip.prototype.getFilenames = function () {
+      /** @type {Array.<string>} */
+      var filenameList = [];
+      /** @type {number} */
+
+      var i;
+      /** @type {number} */
+
+      var il;
+      /** @type {Array.<Zlib.Unzip.FileHeader>} */
+
+      var fileHeaderList;
+
+      if (!this.fileHeaderList) {
+        this.parseFileHeader();
+      }
+
+      fileHeaderList = this.fileHeaderList;
+
+      for (i = 0, il = fileHeaderList.length; i < il; ++i) {
+        filenameList[i] = fileHeaderList[i].filename;
+      }
+
+      return filenameList;
+    };
+    /**
+     * @param {string} filename extract filename.
+     * @param {Object=} opt_params
+     * @return {!(Array.<number>|Uint8Array)} decompressed data.
+     */
+
+
+    Zlib$1.Unzip.prototype.decompress = function (filename, opt_params) {
+      /** @type {number} */
+      var index;
+
+      if (!this.filenameToIndex) {
+        this.parseFileHeader();
+      }
+
+      index = this.filenameToIndex[filename];
+
+      if (index === void 0) {
+        throw new Error(filename + ' not found');
+      }
+
+      return this.getFileData(index, opt_params);
+    };
+    /**
+     * @param {(Array.<number>|Uint8Array)} password
+     */
+
+
+    Zlib$1.Unzip.prototype.setPassword = function (password) {
+      this.password = password;
+    };
+    /**
+     * @param {(Array.<number>|Uint32Array|Object)} key
+     * @param {number} n
+     * @return {number}
+     */
+
+
+    Zlib$1.Unzip.prototype.decode = function (key, n) {
+      n ^= this.getByte(key);
+      this.updateKeys(key, n);
+      return n;
+    }; // common method
+
+
+    Zlib$1.Unzip.prototype.updateKeys = Zlib$1.Zip.prototype.updateKeys;
+    Zlib$1.Unzip.prototype.createDecryptionKey = Zlib$1.Zip.prototype.createEncryptionKey;
+    Zlib$1.Unzip.prototype.getByte = Zlib$1.Zip.prototype.getByte;
+    /**
+     * @fileoverview 雑多な関数群をまとめたモジュール実装.
+     */
+
+    /**
+     * Byte String から Byte Array に変換.
+     * @param {!string} str byte string.
+     * @return {!Array.<number>} byte array.
+     */
+
+    Zlib$1.Util.stringToByteArray = function (str) {
+      /** @type {!Array.<(string|number)>} */
+      var tmp = str.split('');
+      /** @type {number} */
+
+      var i;
+      /** @type {number} */
+
+      var il;
+
+      for (i = 0, il = tmp.length; i < il; i++) {
+        tmp[i] = (tmp[i].charCodeAt(0) & 0xff) >>> 0;
+      }
+
+      return tmp;
+    };
+    /**
+     * @fileoverview Adler32 checksum 実装.
+     */
+
+    /**
+     * Adler32 ハッシュ値の作成
+     * @param {!(Array|Uint8Array|string)} array 算出に使用する byte array.
+     * @return {number} Adler32 ハッシュ値.
+     */
+
+
+    Zlib$1.Adler32 = function (array) {
+      if (typeof array === 'string') {
+        array = Zlib$1.Util.stringToByteArray(array);
+      }
+
+      return Zlib$1.Adler32.update(1, array);
+    };
+    /**
+     * Adler32 ハッシュ値の更新
+     * @param {number} adler 現在のハッシュ値.
+     * @param {!(Array|Uint8Array)} array 更新に使用する byte array.
+     * @return {number} Adler32 ハッシュ値.
+     */
+
+
+    Zlib$1.Adler32.update = function (adler, array) {
+      /** @type {number} */
+      var s1 = adler & 0xffff;
+      /** @type {number} */
+
+      var s2 = adler >>> 16 & 0xffff;
+      /** @type {number} array length */
+
+      var len = array.length;
+      /** @type {number} loop length (don't overflow) */
+
+      var tlen;
+      /** @type {number} array index */
+
+      var i = 0;
+
+      while (len > 0) {
+        tlen = len > Zlib$1.Adler32.OptimizationParameter ? Zlib$1.Adler32.OptimizationParameter : len;
+        len -= tlen;
+
+        do {
+          s1 += array[i++];
+          s2 += s1;
+        } while (--tlen);
+
+        s1 %= 65521;
+        s2 %= 65521;
+      }
+
+      return (s2 << 16 | s1) >>> 0;
+    };
+    /**
+     * Adler32 最適化パラメータ
+     * 現状では 1024 程度が最適.
+     * @see http://jsperf.com/adler-32-simple-vs-optimized/3
+     * @define {number}
+     */
+
+
+    Zlib$1.Adler32.OptimizationParameter = 1024;
+    /**
+     * ビットストリーム
+     * @constructor
+     * @param {!(Array|Uint8Array)=} buffer output buffer.
+     * @param {number=} bufferPosition start buffer pointer.
+     */
+
+    Zlib$1.BitStream = function (buffer, bufferPosition) {
+      /** @type {number} buffer index. */
+      this.index = typeof bufferPosition === 'number' ? bufferPosition : 0;
+      /** @type {number} bit index. */
+
+      this.bitindex = 0;
+      /** @type {!(Array|Uint8Array)} bit-stream output buffer. */
+
+      this.buffer = buffer instanceof (Uint8Array ) ? buffer : new (Uint8Array )(Zlib$1.BitStream.DefaultBlockSize); // 入力された index が足りなかったら拡張するが、倍にしてもダメなら不正とする
+
+      if (this.buffer.length * 2 <= this.index) {
+        throw new Error("invalid index");
+      } else if (this.buffer.length <= this.index) {
+        this.expandBuffer();
+      }
+    };
+    /**
+     * デフォルトブロックサイズ.
+     * @const
+     * @type {number}
+     */
+
+
+    Zlib$1.BitStream.DefaultBlockSize = 0x8000;
+    /**
+     * expand buffer.
+     * @return {!(Array|Uint8Array)} new buffer.
+     */
+
+    Zlib$1.BitStream.prototype.expandBuffer = function () {
+      /** @type {!(Array|Uint8Array)} old buffer. */
+      var oldbuf = this.buffer;
+      /** @type {number} loop limiter. */
+
+      var il = oldbuf.length;
+      /** @type {!(Array|Uint8Array)} new buffer. */
+
+      var buffer = new (Uint8Array )(il << 1); // copy buffer
+
+      {
+        buffer.set(oldbuf);
+      }
+
+      return this.buffer = buffer;
+    };
+    /**
+     * 数値をビットで指定した数だけ書き込む.
+     * @param {number} number 書き込む数値.
+     * @param {number} n 書き込むビット数.
+     * @param {boolean=} reverse é€†é †ã«æ›¸ãè¾¼ã‚€ãªã‚‰ã° true.
+     */
+
+
+    Zlib$1.BitStream.prototype.writeBits = function (number, n, reverse) {
+      var buffer = this.buffer;
+      var index = this.index;
+      var bitindex = this.bitindex;
+      /** @type {number} current octet. */
+
+      var current = buffer[index];
+      /** @type {number} loop counter. */
+
+      var i;
+      /**
+       * 32-bit æ•´æ•°ã®ãƒ“ãƒƒãƒˆé †ã‚’é€†ã«ã™ã‚‹
+       * @param {number} n 32-bit integer.
+       * @return {number} reversed 32-bit integer.
+       * @private
+       */
+
+      function rev32_(n) {
+        return Zlib$1.BitStream.ReverseTable[n & 0xFF] << 24 | Zlib$1.BitStream.ReverseTable[n >>> 8 & 0xFF] << 16 | Zlib$1.BitStream.ReverseTable[n >>> 16 & 0xFF] << 8 | Zlib$1.BitStream.ReverseTable[n >>> 24 & 0xFF];
+      }
+
+      if (reverse && n > 1) {
+        number = n > 8 ? rev32_(number) >> 32 - n : Zlib$1.BitStream.ReverseTable[number] >> 8 - n;
+      } // Byte 境界を超えないとき
+
+
+      if (n + bitindex < 8) {
+        current = current << n | number;
+        bitindex += n; // Byte 境界を超えるとき
+      } else {
+        for (i = 0; i < n; ++i) {
+          current = current << 1 | number >> n - i - 1 & 1; // next byte
+
+          if (++bitindex === 8) {
+            bitindex = 0;
+            buffer[index++] = Zlib$1.BitStream.ReverseTable[current];
+            current = 0; // expand
+
+            if (index === buffer.length) {
+              buffer = this.expandBuffer();
+            }
+          }
+        }
+      }
+
+      buffer[index] = current;
+      this.buffer = buffer;
+      this.bitindex = bitindex;
+      this.index = index;
+    };
+    /**
+     * ストリームの終端処理を行う
+     * @return {!(Array|Uint8Array)} 終端処理後のバッファを byte array で返す.
+     */
+
+
+    Zlib$1.BitStream.prototype.finish = function () {
+      var buffer = this.buffer;
+      var index = this.index;
+      /** @type {!(Array|Uint8Array)} output buffer. */
+
+      var output; // bitindex が 0 の時は余分に index が進んでいる状態
+
+      if (this.bitindex > 0) {
+        buffer[index] <<= 8 - this.bitindex;
+        buffer[index] = Zlib$1.BitStream.ReverseTable[buffer[index]];
+        index++;
+      } // array truncation
+
+
+      {
+        output = buffer.subarray(0, index);
+      }
+
+      return output;
+    };
+    /**
+     * 0-255 ã®ãƒ“ãƒƒãƒˆé †ã‚’åè»¢ã—ãŸãƒ†ãƒ¼ãƒ–ãƒ«
+     * @const
+     * @type {!(Uint8Array|Array.<number>)}
+     */
+
+
+    Zlib$1.BitStream.ReverseTable = function (table) {
+      return table;
+    }(function () {
+      /** @type {!(Array|Uint8Array)} reverse table. */
+      var table = new (Uint8Array )(256);
+      /** @type {number} loop counter. */
+
+      var i; // generate
+
+      for (i = 0; i < 256; ++i) {
+        table[i] = function (n) {
+          var r = n;
+          var s = 7;
+
+          for (n >>>= 1; n; n >>>= 1) {
+            r <<= 1;
+            r |= n & 1;
+            --s;
+          }
+
+          return (r << s & 0xff) >>> 0;
+        }(i);
+      }
+
+      return table;
+    }());
+    /**
+     * CRC32 ハッシュ値を取得
+     * @param {!(Array.<number>|Uint8Array)} data data byte array.
+     * @param {number=} pos data position.
+     * @param {number=} length data length.
+     * @return {number} CRC32.
+     */
+
+    Zlib$1.CRC32.calc = function (data, pos, length) {
+      return Zlib$1.CRC32.update(data, 0, pos, length);
+    };
+    /**
+     * CRC32ハッシュ値を更新
+     * @param {!(Array.<number>|Uint8Array)} data data byte array.
+     * @param {number} crc CRC32.
+     * @param {number=} pos data position.
+     * @param {number=} length data length.
+     * @return {number} CRC32.
+     */
+
+
+    Zlib$1.CRC32.update = function (data, crc, pos, length) {
+      var table = Zlib$1.CRC32.Table;
+      var i = typeof pos === 'number' ? pos : pos = 0;
+      var il = typeof length === 'number' ? length : data.length;
+      crc ^= 0xffffffff; // loop unrolling for performance
+
+      for (i = il & 7; i--; ++pos) {
+        crc = crc >>> 8 ^ table[(crc ^ data[pos]) & 0xff];
+      }
+
+      for (i = il >> 3; i--; pos += 8) {
+        crc = crc >>> 8 ^ table[(crc ^ data[pos]) & 0xff];
+        crc = crc >>> 8 ^ table[(crc ^ data[pos + 1]) & 0xff];
+        crc = crc >>> 8 ^ table[(crc ^ data[pos + 2]) & 0xff];
+        crc = crc >>> 8 ^ table[(crc ^ data[pos + 3]) & 0xff];
+        crc = crc >>> 8 ^ table[(crc ^ data[pos + 4]) & 0xff];
+        crc = crc >>> 8 ^ table[(crc ^ data[pos + 5]) & 0xff];
+        crc = crc >>> 8 ^ table[(crc ^ data[pos + 6]) & 0xff];
+        crc = crc >>> 8 ^ table[(crc ^ data[pos + 7]) & 0xff];
+      }
+
+      return (crc ^ 0xffffffff) >>> 0;
+    };
+    /**
+     * @param {number} num
+     * @param {number} crc
+     * @returns {number}
+     */
+
+
+    Zlib$1.CRC32.single = function (num, crc) {
+      return (Zlib$1.CRC32.Table[(num ^ crc) & 0xff] ^ num >>> 8) >>> 0;
+    };
+    /**
+     * @type {Array.<number>}
+     * @const
+     * @private
+     */
+
+
+    Zlib$1.CRC32.Table_ = [0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de, 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9, 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, 0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599, 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924, 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190, 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01, 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950, 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010, 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f, 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8, 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb, 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, 0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef, 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236, 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe, 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713, 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242, 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9, 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d];
+    /**
+     * @type {!(Array.<number>|Uint32Array)} CRC-32 Table.
+     * @const
+     */
+
+    Zlib$1.CRC32.Table = new Uint32Array(Zlib$1.CRC32.Table_) ;
+    /**
+     * @fileoverview Deflate (RFC1951) 実装.
+     * Deflateアルゴリズム本体は Zlib.RawDeflate で実装されている.
+     */
+
+    /**
+     * Zlib Deflate
+     * @constructor
+     * @param {!(Array|Uint8Array)} input 符号化する対象の byte array.
+     * @param {Object=} opt_params option parameters.
+     */
+
+    Zlib$1.Deflate = function (input, opt_params) {
+      /** @type {!(Array|Uint8Array)} */
+      this.input = input;
+      /** @type {!(Array|Uint8Array)} */
+
+      this.output = new (Uint8Array )(Zlib$1.Deflate.DefaultBufferSize);
+      /** @type {Zlib.Deflate.CompressionType} */
+
+      this.compressionType = Zlib$1.Deflate.CompressionType.DYNAMIC;
+      /** @type {Zlib.RawDeflate} */
+
+      this.rawDeflate;
+      /** @type {Object} */
+
+      var rawDeflateOption = {};
+      /** @type {string} */
+
+      var prop; // option parameters
+
+      if (opt_params || !(opt_params = {})) {
+        if (typeof opt_params['compressionType'] === 'number') {
+          this.compressionType = opt_params['compressionType'];
+        }
+      } // copy options
+
+
+      for (prop in opt_params) {
+        rawDeflateOption[prop] = opt_params[prop];
+      } // set raw-deflate output buffer
+
+
+      rawDeflateOption['outputBuffer'] = this.output;
+      this.rawDeflate = new Zlib$1.RawDeflate(this.input, rawDeflateOption);
+    };
+    /**
+     * @const
+     * @type {number} デフォルトバッファサイズ.
+     */
+
+
+    Zlib$1.Deflate.DefaultBufferSize = 0x8000;
+    /**
+     * @enum {number}
+     */
+
+    Zlib$1.Deflate.CompressionType = Zlib$1.RawDeflate.CompressionType;
+    /**
+     * 直接圧縮に掛ける.
+     * @param {!(Array|Uint8Array)} input target buffer.
+     * @param {Object=} opt_params option parameters.
+     * @return {!(Array|Uint8Array)} compressed data byte array.
+     */
+
+    Zlib$1.Deflate.compress = function (input, opt_params) {
+      return new Zlib$1.Deflate(input, opt_params).compress();
+    };
+    /**
+     * Deflate Compression.
+     * @return {!(Array|Uint8Array)} compressed data byte array.
+     */
+
+
+    Zlib$1.Deflate.prototype.compress = function () {
+      /** @type {Zlib.CompressionMethod} */
+      var cm;
+      /** @type {number} */
+
+      var cinfo;
+      /** @type {number} */
+
+      var cmf;
+      /** @type {number} */
+
+      var flg;
+      /** @type {number} */
+
+      var fcheck;
+      /** @type {number} */
+
+      var fdict;
+      /** @type {number} */
+
+      var flevel;
+      /** @type {number} */
+
+      var adler;
+      /** @type {!(Array|Uint8Array)} */
+
+      var output;
+      /** @type {number} */
+
+      var pos = 0;
+      output = this.output; // Compression Method and Flags
+
+      cm = Zlib$1.CompressionMethod.DEFLATE;
+
+      switch (cm) {
+        case Zlib$1.CompressionMethod.DEFLATE:
+          cinfo = Math.LOG2E * Math.log(Zlib$1.RawDeflate.WindowSize) - 8;
+          break;
+
+        default:
+          throw new Error('invalid compression method');
+      }
+
+      cmf = cinfo << 4 | cm;
+      output[pos++] = cmf; // Flags
+
+      fdict = 0;
+
+      switch (cm) {
+        case Zlib$1.CompressionMethod.DEFLATE:
+          switch (this.compressionType) {
+            case Zlib$1.Deflate.CompressionType.NONE:
+              flevel = 0;
+              break;
+
+            case Zlib$1.Deflate.CompressionType.FIXED:
+              flevel = 1;
+              break;
+
+            case Zlib$1.Deflate.CompressionType.DYNAMIC:
+              flevel = 2;
+              break;
+
+            default:
+              throw new Error('unsupported compression type');
+          }
+
+          break;
+
+        default:
+          throw new Error('invalid compression method');
+      }
+
+      flg = flevel << 6 | fdict << 5;
+      fcheck = 31 - (cmf * 256 + flg) % 31;
+      flg |= fcheck;
+      output[pos++] = flg; // Adler-32 checksum
+
+      adler = Zlib$1.Adler32(this.input);
+      this.rawDeflate.op = pos;
+      output = this.rawDeflate.compress();
+      pos = output.length;
+
+      {
+        // subarray 分を元にもどす
+        output = new Uint8Array(output.buffer); // expand buffer
+
+        if (output.length <= pos + 4) {
+          this.output = new Uint8Array(output.length + 4);
+          this.output.set(output);
+          output = this.output;
+        }
+
+        output = output.subarray(0, pos + 4);
+      } // adler32
+
+
+      output[pos++] = adler >> 24 & 0xff;
+      output[pos++] = adler >> 16 & 0xff;
+      output[pos++] = adler >> 8 & 0xff;
+      output[pos++] = adler & 0xff;
+      return output;
+    };
+
+    /**
+     * Covers string literals and String objects
+     * @param x
+     * @returns {boolean}
+     */
+
+    function isString$6(x) {
+      return typeof x === "string" || x instanceof String;
+    } // StackOverflow: http://stackoverflow.com/a/10810674/116169
+
+
+    function numberFormatter$1(rawNumber) {
+      var dec = String(rawNumber).split(/[.,]/),
+          sep = ',',
+          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] : '');
+    }
+
+    const splitLines$3 = function (string) {
+      return string.split(/\n|\r\n|\r/g);
+    };
+
+    function splitStringRespectingQuotes(string, delim) {
+      var tokens = [],
+          len = string.length,
+          i,
+          n = 0,
+          quote = false,
+          c;
+
+      if (len > 0) {
+        tokens[n] = string.charAt(0);
+
+        for (i = 1; i < len; i++) {
+          c = string.charAt(i);
+
+          if (c === '"') {
+            quote = !quote;
+          } else if (!quote && c === delim) {
+            n++;
+            tokens[n] = "";
+          } else {
+            tokens[n] += c;
+          }
+        }
+      }
+
+      return tokens;
+    }
+
+    function stripQuotes(str) {
+      if (str === undefined) {
+        return str;
+      }
+
+      if (str.startsWith("'") || str.startsWith('"')) {
+        str = str.substring(1);
+      }
+
+      if (str.endsWith("'") || str.endsWith('"')) {
+        str = str.substring(0, str.length - 1);
+      }
+
+      return str;
+    }
+
+    function hashCode$1(s) {
+      return s.split("").reduce(function (a, b) {
+        a = (a << 5) - a + b.charCodeAt(0);
+        return a & a;
+      }, 0);
+    }
+    /**
+     * Compress string and encode in a url safe form
+     * @param s
+     */
+
+
+    function compressString(str) {
+      const bytes = [];
+
+      for (var i = 0; i < str.length; i++) {
+        bytes.push(str.charCodeAt(i));
+      }
+
+      const compressedBytes = new Zlib$1.RawDeflate(bytes).compress(); // 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
+    }
+    /**
+     * Uncompress the url-safe encoded compressed string, presumably created by compressString above
+     *
+     * @param enc
+     * @returns {string}
+     */
+
+
+    function uncompressString(enc) {
+      enc = enc.replace(/\./g, '+').replace(/_/g, '/').replace(/-/g, '=');
+      const compressedString = atob(enc);
+      const compressedBytes = [];
+
+      for (let i = 0; i < compressedString.length; i++) {
+        compressedBytes.push(compressedString.charCodeAt(i));
+      }
+
+      const bytes = new Zlib$1.RawInflate(compressedBytes).decompress();
+      let str = '';
+
+      for (let b of bytes) {
+        str += String.fromCharCode(b);
+      }
+
+      return str;
+    }
+
+    function capitalize(str) {
+      return str.length > 0 ? str.charAt(0).toUpperCase() + str.slice(1) : str;
+    }
+    /**
+     * Parse a locus string and return a range object.  Locus string is of the form chr:start-end.  End is optional
+     *
+     */
+
+
+    function parseLocusString$1(string) {
+      const t1 = string.split(":");
+      const t2 = t1[1].split("-");
+      const range = {
+        chr: t1[0],
+        start: Number.parseInt(t2[0].replace(/,/g, '')) - 1
+      };
+
+      if (t2.length > 1) {
+        range.end = Number.parseInt(t2[1].replace(/,/g, ''));
+      } else {
+        range.end = range.start + 1;
+      }
+
+      return range;
+    }
+
+    const FileFormats = {
+      gwascatalog: {
+        fields: ['bin', 'chr', 'start', 'end', 'name', 'pubMedID', 'author', 'pubDate', 'journal', 'title', 'trait', 'initSample', 'replSample', 'region', 'genes', 'riskAllele', 'riskAlFreq', 'pValue', 'pValueDesc', 'orOrBeta', 'ci95', 'platform', 'cnv']
+      },
+      wgrna: {
+        fields: ['bin', 'chr', 'start', 'end', 'name', 'score', 'strand', 'thickStart', 'thickEnd', 'type']
+      },
+      cpgislandext: {
+        fields: ['bin', 'chr', 'start', 'end', 'name', 'length', 'cpgNum', 'gcNum', 'perCpg', 'perGc', 'obsExp']
+      },
+      clinVarMain: {
+        fields: ['chr1', 'start', 'end', 'name', 'score', 'strand', 'thickStart', 'thickEnd', 'reserved', 'blockCount', // Number of blocks
+        'blockSizes', // Comma separated list of block sizes
+        'chromStarts', // Start positions relative to chromStart
+        'origName', // NM_198053.2(CD247):c.462C>T (p.Asp154=)	ClinVar Variation Report
+        'clinSign', // Likely benign	Clinical significance
+        'reviewStatus', // 	based on: criteria provided,single submitter	Review Status
+        'type', // single nucleotide variant	Type of Variant
+        'geneId', // CD247	Gene Symbol
+        'snpId', //	181656780	dbSNP ID
+        'nsvId', //		dbVar ID
+        'rcvAcc', //	RCV000642347	ClinVar Allele Submission
+        'testedInGtr', //	N	Genetic Testing Registry
+        'phenotypeList', //	Immunodeficiency due to defect in cd3-zeta	Phenotypes
+        'phenotype', //	MedGen:C1857798, OMIM:610163	Phenotype identifiers
+        'origin', //	germline	Data origin
+        'assembly', //	GRCh37	Genome assembly
+        'cytogenetic', //	1q24.2	Cytogenetic status
+        'hgvsCod', //	NM_198053.2:c.462C>T	Nucleotide HGVS
+        'hgvsProt', //	NP_932170.1:p.Asp154=	Protein HGVS
+        'numSubmit', //	1	Number of submitters
+        'lastEval', //	Dec 19,2017	Last evaluation
+        'guidelines', //		Guidelines
+        'otherIds']
+      }
+    };
+
+    /*
+     * The MIT License (MIT)
+     *
+     * Copyright (c) 2014 Broad Institute
+     *
+     * Permission is hereby granted, free of charge, to any person obtaining a copy
+     * of this software and associated documentation files (the "Software"), to deal
+     * in the Software without restriction, including without limitation the rights
+     * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+     * copies of the Software, and to permit persons to whom the Software is
+     * furnished to do so, subject to the following conditions:
+     *
+     * The above copyright notice and this permission notice shall be included in
+     * all copies or substantial portions of the Software.
+     *
+     *
+     * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+     * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+     * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+     * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+     * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+     * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+     * THE SOFTWARE.
+     */
+    const knownFileExtensions = new Set(["narrowpeak", "broadpeak", "regionpeak", "peaks", "bedgraph", "wig", "gff3", "gff", "gtf", "fusionjuncspan", "refflat", "seg", "aed", "bed", "vcf", "bb", "bigbed", "bw", "bigwig", "bam", "tdf", "refgene", "genepred", "genepredext", "bedpe", "bp", "snp", "rmsk", "cram", "gwas"]);
+    /**
+     * Return a custom format object with the given name.
+     * @param name
+     * @returns {*}
+     */
+
+    function getFormat(name) {
+      if (FileFormats && FileFormats[name]) {
+        return expandFormat(FileFormats[name]);
+      } else {
+        return undefined;
+      }
+
+      function expandFormat(format) {
+        const fields = format.fields;
+        const keys = ['chr', 'start', 'end'];
+
+        for (let i = 0; i < fields.length; i++) {
+          for (let key of keys) {
+            if (key === fields[i]) {
+              format[key] = i;
+            }
+          }
+        }
+
+        return format;
+      }
+    }
+
+    function inferFileFormat(fn) {
+      var idx, ext;
+      fn = fn.toLowerCase(); // Special case -- UCSC refgene files
+
+      if (fn.endsWith("refgene.txt.gz") || fn.endsWith("refgene.txt.bgz") || fn.endsWith("refgene.txt") || fn.endsWith("refgene.sorted.txt.gz") || fn.endsWith("refgene.sorted.txt.bgz")) {
+        return "refgene";
+      } //Strip parameters -- handle local files later
+
+
+      idx = fn.indexOf("?");
+
+      if (idx > 0) {
+        fn = fn.substr(0, idx);
+      } //Strip aux extensions .gz, .tab, and .txt
+
+
+      if (fn.endsWith(".gz")) {
+        fn = fn.substr(0, fn.length - 3);
+      }
+
+      if (fn.endsWith(".txt") || fn.endsWith(".tab") || fn.endsWith(".bgz")) {
+        fn = fn.substr(0, fn.length - 4);
+      }
+
+      idx = fn.lastIndexOf(".");
+      ext = idx < 0 ? fn : fn.substr(idx + 1);
+
+      switch (ext) {
+        case "bw":
+          return "bigwig";
+
+        case "bb":
+          return "bigbed";
+
+        default:
+          if (knownFileExtensions.has(ext)) {
+            return ext;
+          } else {
+            return undefined;
+          }
+
+      }
+    }
+
+    function inferIndexPath(url, extension) {
+      var idx;
+
+      if (url instanceof File) {
+        throw new Error("Cannot infer an index path for a local File.  Please select explicitly");
+      }
+
+      if (url.includes("?")) {
+        idx = url.indexOf("?");
+        return url.substring(0, idx) + "." + extension + url.substring(idx);
+      } else {
+        return url + "." + extension;
+      }
+    }
+
+    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);
+        }
+      }
+
+      if (bucket && object) {
+        return {
+          bucket,
+          object
+        };
+      } else {
+        throw Error(`Unrecognized Google Storage URI: ${url}`);
+      }
+    }
+
+    function driveDownloadURL(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);
+    }
+    /**
+     * Percent a GCS object name.  See https://cloud.google.com/storage/docs/request-endpoints
+     * Specific characters to encode:
+     *   !, #, $, &, ', (, ), *, +, ,, /, :, ;, =, ?, @, [, ], and space characters.
+     * @param obj
+     */
+
+
+    function encode(objectName) {
+      let result = '';
+      objectName.split('').forEach(function (letter) {
+        if (encodings$1.has(letter)) {
+          result += encodings$1.get(letter);
+        } else {
+          result += letter;
+        }
+      });
+      return result;
+    } //	%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"); // For testing
+
+    // Convenience functions for the gapi oAuth library.
+    const FIVE_MINUTES = 5 * 60 * 1000;
+
+    async function load$1(library) {
+      return new Promise(function (resolve, reject) {
+        gapi.load(library, {
+          callback: resolve,
+          onerror: reject
+        });
+      });
+    }
+
+    async function init$1(config) {
+      if (isInitialized()) {
+        console.warn("oAuth has already been initialized");
+        return;
+      }
+
+      gapi.apiKey = config.apiKey; // copy config, gapi will modify it
+
+      const configCopy = Object.assign({}, config);
+
+      if (!configCopy.scope) {
+        configCopy.scope = 'profile';
+      }
+
+      if (!config.client_id) {
+        config.client_id = config.clientId;
+      }
+
+      await load$1("auth2");
+      return new Promise(function (resolve, reject) {
+        gapi.auth2.init(configCopy).then(resolve, reject);
+      });
+    }
+
+    function isInitialized() {
+      return typeof gapi !== "undefined" && gapi.auth2 && gapi.auth2.getAuthInstance();
+    }
+
+    let inProgress = false;
+
+    async function getAccessToken(scope) {
+      if (typeof gapi === "undefined") {
+        throw Error("Google authentication requires the 'gapi' library");
+      }
+
+      if (!gapi.auth2) {
+        throw Error("Google 'auth2' has not been initialized");
+      }
+
+      if (inProgress) {
+        return new Promise(function (resolve, reject) {
+          let intervalID;
+
+          const checkForToken = () => {
+            // Wait for inProgress to equal "false"
+            try {
+              if (inProgress === false) {
+                //console.log("Delayed resolution for " + scope);
+                resolve(getAccessToken(scope));
+                clearInterval(intervalID);
+              }
+            } catch (e) {
+              clearInterval(intervalID);
+              reject(e);
+            }
+          };
+
+          intervalID = setInterval(checkForToken, 100);
+        });
+      } else {
+        inProgress = true;
+
+        try {
+          let currentUser = gapi.auth2.getAuthInstance().currentUser.get();
+          let token;
+
+          if (currentUser.isSignedIn()) {
+            if (!currentUser.hasGrantedScopes(scope)) {
+              await currentUser.grant({
+                scope
+              });
+            }
+
+            const {
+              access_token,
+              expires_at
+            } = currentUser.getAuthResponse();
+
+            if (Date.now() < expires_at - FIVE_MINUTES) {
+              token = {
+                access_token,
+                expires_at
+              };
+            } else {
+              const {
+                access_token,
+                expires_at
+              } = currentUser.reloadAuthResponse();
+              token = {
+                access_token,
+                expires_at
+              };
+            }
+          } else {
+            currentUser = await signIn(scope);
+            const {
+              access_token,
+              expires_at
+            } = currentUser.getAuthResponse();
+            token = {
+              access_token,
+              expires_at
+            };
+          }
+
+          return token;
+        } finally {
+          inProgress = false;
+        }
+      }
+    }
+    /**
+     * Return the current access token if the user is signed in, or undefined otherwise.  This function does not
+     * attempt a signIn or request any specfic scopes.
+     *
+     * @returns access_token || undefined
+     */
+
+
+    function getCurrentAccessToken() {
+      let currentUser = gapi.auth2.getAuthInstance().currentUser.get();
+
+      if (currentUser && currentUser.isSignedIn()) {
+        const {
+          access_token,
+          expires_at
+        } = currentUser.getAuthResponse();
+        return {
+          access_token,
+          expires_at
+        };
+      } else {
+        return undefined;
+      }
+    }
+
+    async function signIn(scope) {
+      const options = new gapi.auth2.SigninOptionsBuilder();
+      options.setPrompt('select_account');
+      options.setScope(scope);
+      return gapi.auth2.getAuthInstance().signIn(options);
+    }
+
+    function getScopeForURL(url) {
+      if (isGoogleDriveURL(url)) {
+        return "https://www.googleapis.com/auth/drive.file";
+      } else if (isGoogleStorageURL(url)) {
+        return "https://www.googleapis.com/auth/devstorage.read_only";
+      } else {
+        return 'https://www.googleapis.com/auth/userinfo.profile';
+      }
+    }
+
+    function getApiKey() {
+      return gapi.apiKey;
+    }
+
+    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) {
+        const {
+          access_token
+        } = await getAccessToken("https://www.googleapis.com/auth/drive.readonly");
+
+        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;
+    }
+
+    if (typeof process === 'object' && typeof window === 'undefined') {
+      global.atob = function (str) {
+        return Buffer.from(str, 'base64').toString('binary');
+      };
+    }
+    /**
+     * @param dataURI
+     * @returns {Array<number>|Uint8Array}
+     */
+
+
+    function decodeDataURI$1(dataURI) {
+      const split = dataURI.split(',');
+      const info = split[0].split(':')[1];
+      let dataString = split[1];
+
+      if (info.indexOf('base64') >= 0) {
+        dataString = atob(dataString);
+      } else {
+        dataString = decodeURI(dataString); // URL encoded string -- not currently used of tested
+      }
+
+      const bytes = new Uint8Array(dataString.length);
+
+      for (let i = 0; i < dataString.length; i++) {
+        bytes[i] = dataString.charCodeAt(i);
+      }
+
+      let plain;
+
+      if (info.indexOf('gzip') > 0) {
+        const inflate = new Zlib$1.Gunzip(bytes);
+        plain = inflate.decompress();
+      } else {
+        plain = bytes;
+      }
+
+      return plain;
+    }
+
+    function parseUri(str) {
+      var o = options,
+          m = o.parser["loose"].exec(str),
+          uri = {},
+          i = 14;
+
+      while (i--) uri[o.key[i]] = m[i] || "";
+
+      uri[o.q.name] = {};
+      uri[o.key[12]].replace(o.q.parser, function ($0, $1, $2) {
+        if ($1) uri[o.q.name][$1] = $2;
+      });
+      return uri;
+    }
+
+    const options = {
+      strictMode: false,
+      key: ["source", "protocol", "authority", "userInfo", "user", "password", "host", "port", "relative", "path", "directory", "file", "query", "anchor"],
+      q: {
+        name: "queryKey",
+        parser: /(?:^|&)([^&=]*)=?([^&]*)/g
+      },
+      parser: {
+        strict: /^(?:([^:\/?#]+):)?(?:\/\/((?:(([^:@]*)(?::([^:@]*))?)?@)?([^:\/?#]*)(?::(\d*))?))?((((?:[^?#\/]*\/)*)([^?#]*))(?:\?([^#]*))?(?:#(.*))?)/,
+        loose: /^(?:(?![^:@]+:[^:@\/]*@)([^:\/?#.]+):)?(?:\/\/)?((?:(([^:@]*)(?::([^:@]*))?)?@)?([^:\/?#]*)(?::(\d*))?)(((\/(?:[^?#](?![^?#\/]*\.[^?#\/.]+(?:[?#]|$)))*\/?)?([^?#\/]*))(?:\?([^#]*))?(?:#(.*))?)/
+      }
+    };
+    /**
+     * Resolve a url, which might be a string, function (that returns a string or Promse), or Promise (that resolves to a string)
+     *
+     * @param url
+     * @returns {Promise<*>}
+     */
+
+
+    async function resolveURL(url) {
+      return typeof url === 'function' ? url() : url;
+    }
+
+    /**
+     * Return the filename from the path.   Example
+     *   https://foo.com/bar.bed?param=2   => bar.bed
+     * @param urlOrFile
+     */
+
+
+    function getFilename$2(urlOrFile) {
+      if (urlOrFile instanceof File) {
+        return urlOrFile.name;
+      } else if (isString$6(urlOrFile)) {
+        let index = urlOrFile.lastIndexOf("/");
+        let filename = index < 0 ? urlOrFile : urlOrFile.substr(index + 1); //Strip parameters -- handle local files later
+
+        index = filename.indexOf("?");
+
+        if (index > 0) {
+          filename = filename.substr(0, index);
+        }
+
+        return filename;
+      } else {
+        throw Error(`Expected File or string, got ${typeof urlOrFile}`);
+      }
+    }
+
+    function isFilePath(path) {
+      return path instanceof File;
+    }
+
+    function download(filename, data) {
+      const element = document.createElement('a');
+      element.setAttribute('href', data);
+      element.setAttribute('download', filename);
+      element.style.display = 'none';
+      document.body.appendChild(element);
+      element.click();
+      document.body.removeChild(element);
+    }
+
+    // Uncompress data,  assumed to be series of bgzipped blocks
+
+    function unbgzf(data, lim) {
+      const oBlockList = [];
+      let ptr = 0;
+      let totalSize = 0;
+      lim = lim || data.byteLength - 18;
+
+      while (ptr < lim) {
+        try {
+          const ba = new Uint8Array(data, ptr, 18);
+          const xlen = ba[11] << 8 | ba[10];
+          const si1 = ba[12];
+          const si2 = ba[13];
+          const slen = ba[15] << 8 | ba[14];
+          const bsize = (ba[17] << 8 | ba[16]) + 1;
+          const start = 12 + xlen + ptr; // Start of CDATA
+
+          const bytesLeft = data.byteLength - start;
+          const cDataSize = bsize - xlen - 19;
+          if (bytesLeft < cDataSize || cDataSize <= 0) break;
+          const a = new Uint8Array(data, start, cDataSize);
+          const inflate = new Zlib$1.RawInflate(a);
+          const unc = inflate.decompress();
+          ptr += inflate.ip + 26;
+          totalSize += unc.byteLength;
+          oBlockList.push(unc);
+        } catch (e) {
+          console.error(e);
+          break;
+        }
+      } // Concatenate decompressed blocks
+
+
+      if (oBlockList.length === 1) {
+        return oBlockList[0];
+      } else {
+        const out = new Uint8Array(totalSize);
+        let cursor = 0;
+
+        for (let i = 0; i < oBlockList.length; ++i) {
+          var b = new Uint8Array(oBlockList[i]);
+          arrayCopy(b, 0, out, cursor, b.length);
+          cursor += b.length;
+        }
+
+        return out;
+      }
+    }
+
+    function bgzBlockSize(data) {
+      const ba = new Uint8Array(data);
+      const bsize = (ba[17] << 8 | ba[16]) + 1;
+      return bsize;
+    } // From Thomas Down's zlib implementation
+
+
+    const testArray = new Uint8Array(1);
+    const hasSubarray = typeof testArray.subarray === 'function';
+    /* (typeof testArray.slice === 'function'); */
+    // Chrome slice performance is so dire that we're currently not using it...
+
+    function arrayCopy(src, srcOffset, dest, destOffset, count) {
+      if (count === 0) {
+        return;
+      }
+
+      if (!src) {
+        throw "Undef src";
+      } else if (!dest) {
+        throw "Undef dest";
+      }
+
+      if (srcOffset === 0 && count === src.length) {
+        arrayCopy_fast(src, dest, destOffset);
+      } else if (hasSubarray) {
+        arrayCopy_fast(src.subarray(srcOffset, srcOffset + count), dest, destOffset);
+      } else if (src.BYTES_PER_ELEMENT === 1 && count > 100) {
+        arrayCopy_fast(new Uint8Array(src.buffer, src.byteOffset + srcOffset, count), dest, destOffset);
+      } else {
+        arrayCopy_slow(src, srcOffset, dest, destOffset, count);
+      }
+    }
+
+    function arrayCopy_slow(src, srcOffset, dest, destOffset, count) {
+      for (let i = 0; i < count; ++i) {
+        dest[destOffset + i] = src[srcOffset + i];
+      }
+    }
+
+    function arrayCopy_fast(src, dest, destOffset) {
+      dest.set(src, destOffset);
+    }
+
+    /*
+     * The MIT License (MIT)
+     *
+     * Copyright (c) 2016-2017 The Regents of the University of California
+     * Author: Jim Robinson
+     *
+     * Permission is hereby granted, free of charge, to any person obtaining a copy
+     * of this software and associated documentation files (the "Software"), to deal
+     * in the Software without restriction, including without limitation the rights
+     * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+     * copies of the Software, and to permit persons to whom the Software is
+     * furnished to do so, subject to the following conditions:
+     *
+     * The above copyright notice and this permission notice shall be included in
+     * all copies or substantial portions of the Software.
+     *
+     *
+     * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+     * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+     * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+     * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+     * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+     * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+     * THE SOFTWARE.
+     */
+    const IGVMath = {
+      lerp: (v0, v1, t) => {
+        return (1 - t) * v0 + t * v1;
+      },
+      mean: function (array) {
+        var t = 0,
+            n = 0,
+            i;
+
+        for (i = 0; i < array.length; i++) {
+          if (!isNaN(array[i])) {
+            t += array[i];
+            n++;
+          }
+        }
+
+        return n > 0 ? t / n : 0;
+      },
+      meanAndStdev: function (array) {
+        var v,
+            t = 0,
+            t2 = 0,
+            n = 0,
+            i;
+
+        for (i = 0; i < array.length; i++) {
+          v = array[i];
+
+          if (!isNaN(v)) {
+            t += v;
+            t2 += v * v;
+            n++;
+          }
+        }
+
+        return n > 0 ? {
+          mean: t / n,
+          stdev: Math.sqrt(t2 - t * t / n)
+        } : {
+          mean: 0,
+          stdev: 0
+        };
+      },
+      median: function (numbers) {
+        // median of [3, 5, 4, 4, 1, 1, 2, 3] = 3
+        var median = 0,
+            numsLen = numbers.length;
+        numbers.sort();
+
+        if (numsLen % 2 === 0 // is even
+        ) {
+          // average of two middle numbers
+          median = (numbers[numsLen / 2 - 1] + numbers[numsLen / 2]) / 2;
+        } else {
+          // is odd
+          // middle number only
+          median = numbers[(numsLen - 1) / 2];
+        }
+
+        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;
+        var k = Math.floor(array.length * ((100 - p) / 100));
+
+        if (k === 0) {
+          array.sort(function (a, b) {
+            return b - a;
+          });
+          return array[k];
+        } else {
+          return selectElement(array, k);
+        }
+      },
+      clamp: function (value, min, max) {
+        return Math.min(Math.max(value, min), max);
+      },
+      log2: function (x) {
+        return Math.log(x) / Math.LN2;
+      }
+    };
+
+    function selectElement(array, k) {
+      // Credit Steve Hanov http://stevehanov.ca/blog/index.php?id=122
+      var heap = new BinaryHeap(),
+          i;
+
+      for (i = 0; i < array.length; i++) {
+        var item = array[i]; // If we have not yet found k items, or the current item is larger than
+        // the smallest item on the heap, add current item
+
+        if (heap.content.length < k || item > heap.content[0]) {
+          // If the heap is full, remove the smallest element on the heap.
+          if (heap.content.length === k) {
+            heap.pop();
+          }
+
+          heap.push(item);
+        }
+      }
+
+      return heap.content[0];
+    }
+
+    function BinaryHeap() {
+      this.content = [];
+    }
+
+    BinaryHeap.prototype = {
+      push: function (element) {
+        // Add the new element to the end of the array.
+        this.content.push(element); // Allow it to bubble up.
+
+        this.bubbleUp(this.content.length - 1);
+      },
+      pop: function () {
+        // Store the first element so we can return it later.
+        var result = this.content[0]; // Get the element at the end of the array.
+
+        var end = this.content.pop(); // If there are any elements left, put the end element at the
+        // start, and let it sink down.
+
+        if (this.content.length > 0) {
+          this.content[0] = end;
+          this.sinkDown(0);
+        }
+
+        return result;
+      },
+      remove: function (node) {
+        var length = this.content.length; // 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; // 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; // 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;
+        }
+      },
+      size: function () {
+        return this.content.length;
+      },
+      bubbleUp: function (n) {
+        // Fetch the element that has to be moved.
+        var element = this.content[n],
+            score = element; // When at 0, an element can not go up any further.
+
+        while (n > 0) {
+          // Compute the parent element's index, and fetch it.
+          var parentN = Math.floor((n + 1) / 2) - 1,
+              parent = this.content[parentN]; // If the parent has a lesser score, things are in order and we
+          // are done.
+
+          if (score >= parent) break; // Otherwise, swap the parent with the current element and
+          // continue.
+
+          this.content[parentN] = element;
+          this.content[n] = parent;
+          n = parentN;
+        }
+      },
+      sinkDown: function (n) {
+        // Look up the target element and its score.
+        var length = this.content.length,
+            element = this.content[n],
+            elemScore = element;
+
+        while (true) {
+          // Compute the indices of the child elements.
+          var child2N = (n + 1) * 2,
+              child1N = child2N - 1; // This is used to store the new position of the element,
+          // if any.
+
+          var swap = null; // If the first child exists (is inside the array)...
+
+          if (child1N < length) {
+            // Look it up and compute its score.
+            var child1 = this.content[child1N],
+                child1Score = child1; // If the score is less than our element's, we need to swap.
+
+            if (child1Score < elemScore) swap = child1N;
+          } // Do the same checks for the other child.
+
+
+          if (child2N < length) {
+            var child2 = this.content[child2N],
+                child2Score = child2;
+            if (child2Score < (swap == null ? elemScore : child1Score)) swap = child2N;
+          } // No need to swap further, we are done.
+
+
+          if (swap == null) break; // Otherwise, swap and continue.
+
+          this.content[n] = this.content[swap];
+          this.content[swap] = element;
+          n = swap;
+        }
+      }
+    };
+
+    /*
+     * The MIT License (MIT)
+     *
+     * Copyright (c) 2014 Broad Institute
+     *
+     * Permission is hereby granted, free of charge, to any person obtaining a copy
+     * of this software and associated documentation files (the "Software"), to deal
+     * in the Software without restriction, including without limitation the rights
+     * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+     * copies of the Software, and to permit persons to whom the Software is
+     * furnished to do so, subject to the following conditions:
+     *
+     * The above copyright notice and this permission notice shall be included in
+     * all copies or substantial portions of the Software.
+     *
+     *
+     * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+     * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+     * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+     * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+     * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+     * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+     * THE SOFTWARE.
+     */
+
+    function _random(min, max) {
+      return Math.random() * (max - min) + min;
+    }
+
+    const IGVColor = {
+      rgbListFromHSV: () => {
+        let s = 1;
+        let accumulation = [];
+
+        for (let v = 1; v >= 0.5; v -= .1) {
+          for (let h = 0; h < 1; h += 1 / 28) {
+            const r = "rgb(" + IGVColor.hsvToRgb(h, s, v).join(",") + ")";
+            accumulation.push(r);
+          }
+        } // add black
+
+
+        accumulation.pop();
+        accumulation.push(IGVColor.rgbColor(16, 16, 16));
+        return accumulation;
+      },
+      rgbToHex: function (rgb) {
+        rgb = rgb.match(/^rgba?[\s+]?\([\s+]?(\d+)[\s+]?,[\s+]?(\d+)[\s+]?,[\s+]?(\d+)[\s+]?/i);
+        return rgb && rgb.length === 4 ? "#" + ("0" + parseInt(rgb[1], 10).toString(16)).slice(-2) + ("0" + parseInt(rgb[2], 10).toString(16)).slice(-2) + ("0" + parseInt(rgb[3], 10).toString(16)).slice(-2) : '';
+      },
+      hexToRgb: function (hex) {
+        var cooked = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
+
+        if (null === cooked) {
+          return undefined;
+        }
+
+        return "rgb(" + parseInt(cooked[1], 16) + "," + parseInt(cooked[2], 16) + "," + parseInt(cooked[3], 16) + ")";
+      },
+
+      /**
+       * Converts an HSV color value to RGB. Conversion formula
+       * adapted from http://en.wikipedia.org/wiki/HSV_color_space.
+       * Assumes h, s, and v are contained in the set [0, 1] and
+       * returns r, g, and b in the set [0, 255].
+       *
+       * Credit: https://gist.githubusercontent.com/mjackson/5311256
+       *
+       * @param   h       The hue
+       * @param   s       The saturation
+       * @param   v       The value
+       * @return  Array   The RGB representation
+       */
+      hsvToRgb: function (h, s, v) {
+        var r, g, b;
+        var i = Math.floor(h * 6);
+        var f = h * 6 - i;
+        var p = v * (1 - s);
+        var q = v * (1 - f * s);
+        var t = v * (1 - (1 - f) * s);
+
+        switch (i % 6) {
+          case 0:
+            r = v, g = t, b = p;
+            break;
+
+          case 1:
+            r = q, g = v, b = p;
+            break;
+
+          case 2:
+            r = p, g = v, b = t;
+            break;
+
+          case 3:
+            r = p, g = q, b = v;
+            break;
+
+          case 4:
+            r = t, g = p, b = v;
+            break;
+
+          case 5:
+            r = v, g = p, b = q;
+            break;
+        }
+
+        return [Math.floor(r * 255), Math.floor(g * 255), Math.floor(b * 255)];
+      },
+
+      /**
+       * Converts an HSL color value to RGB. Conversion formula
+       * adapted from http://en.wikipedia.org/wiki/HSL_color_space.
+       * Assumes h, s, and l are contained in the set [0, 1] and
+       * returns r, g, and b in the set [0, 255].
+       *
+       * Credit: https://gist.githubusercontent.com/mjackson/5311256
+       *
+       * @param   h       The hue
+       * @param   s       The saturation
+       * @param   l       The lightness
+       * @return  Array   The RGB representation
+       */
+      hslToRgb: function (h, s, l) {
+        var r, g, b;
+
+        if (s === 0) {
+          r = g = b = l; // achromatic
+        } else {
+          var q = l < 0.5 ? l * (1 + s) : l + s - l * s;
+          var p = 2 * l - q;
+          r = IGVColor.hue2rgb(p, q, h + 1 / 3);
+          g = IGVColor.hue2rgb(p, q, h);
+          b = IGVColor.hue2rgb(p, q, h - 1 / 3);
+        }
+
+        return [r * 255, g * 255, b * 255];
+      },
+      hue2rgb: (p, q, t) => {
+        if (t < 0) t += 1;
+        if (t > 1) t -= 1;
+        if (t < 1 / 6) return p + (q - p) * 6 * t;
+        if (t < 1 / 2) return q;
+        if (t < 2 / 3) return p + (q - p) * (2 / 3 - t) * 6;
+        return p;
+      },
+      rgbaColor: function (r, g, b, a) {
+        r = IGVMath.clamp(r, 0, 255);
+        g = IGVMath.clamp(g, 0, 255);
+        b = IGVMath.clamp(b, 0, 255);
+        a = IGVMath.clamp(a, 0.0, 1.0);
+        return "rgba(" + r + "," + g + "," + b + "," + a + ")";
+      },
+      rgbColor: function (r, g, b) {
+        r = IGVMath.clamp(r, 0, 255);
+        g = IGVMath.clamp(g, 0, 255);
+        b = IGVMath.clamp(b, 0, 255);
+        return "rgb(" + r + "," + g + "," + b + ")";
+      },
+      greyScale: function (value) {
+        var grey = IGVMath.clamp(value, 0, 255);
+        return "rgb(" + grey + "," + grey + "," + grey + ")";
+      },
+      randomGrey: function (min, max) {
+        min = IGVMath.clamp(min, 0, 255);
+        max = IGVMath.clamp(max, 0, 255);
+        var g = Math.round(_random(min, max)).toString(10);
+        return "rgb(" + g + "," + g + "," + g + ")";
+      },
+      randomRGB: function (min, max) {
+        min = IGVMath.clamp(min, 0, 255);
+        max = IGVMath.clamp(max, 0, 255);
+        var r = Math.round(_random(min, max)).toString(10);
+        var g = Math.round(_random(min, max)).toString(10);
+        var b = Math.round(_random(min, max)).toString(10);
+        return "rgb(" + r + "," + g + "," + b + ")";
+      },
+      randomRGBConstantAlpha: function (min, max, alpha) {
+        min = IGVMath.clamp(min, 0, 255);
+        max = IGVMath.clamp(max, 0, 255);
+        var r = Math.round(_random(min, max)).toString(10);
+        var g = Math.round(_random(min, max)).toString(10);
+        var b = Math.round(_random(min, max)).toString(10);
+        return "rgba(" + r + "," + g + "," + b + "," + alpha + ")";
+      },
+      addAlpha: function (color, alpha) {
+        if (color === "0" || color === ".") {
+          color = "rgb(0,0,0)";
+        } else {
+          const c = this.colorNameToHex(color);
+
+          if (c) {
+            color = c;
+          }
+        }
+
+        var isHex = /(^#[0-9A-F]{6}$)|(^#[0-9A-F]{3}$)/i.test(color);
+
+        if (color.startsWith("rgba")) {
+          const idx = color.lastIndexOf(",");
+          return color.substring(0, idx + 1) + alpha.toString() + ")";
+        }
+
+        if (isHex) {
+          color = IGVColor.hexToRgb(color);
+        }
+
+        if (color.startsWith("rgb")) {
+          return color.replace("rgb", "rgba").replace(")", ", " + alpha + ")");
+        } else {
+          return color;
+        }
+      },
+      rgbComponents: function (color) {
+        if (color === "0" || color === ".") {
+          return [0, 0, 0];
+        }
+
+        const isHex = /(^#[0-9A-F]{6}$)|(^#[0-9A-F]{3}$)/i.test(color);
+
+        if (isHex) {
+          color = IGVColor.hexToRgb(color);
+        } else {
+          if (!color.startsWith("rgb")) {
+            const hex = this.colorNameToHex(color);
+            color = this.hexToRgb(hex);
+          }
+        }
+
+        if (color.startsWith("rgb(")) {
+          return color.substring(4, color.length - 1).split(",").map(s => Number.parseInt(s.trim()));
+        } else if (color.startsWith("rgba(")) {
+          return color.substring(5, color.length - 1).split(",").map((s, i) => {
+            s = s.trim();
+            return i === 3 ? Number.parseFloat(s) : Number.parseInt(s);
+          });
+        } else {
+          throw Error("Unrecognized color string: color");
+        }
+      },
+
+      /**
+       *
+       * @param dest  RGB components as an array
+       * @param src  RGB components as an array
+       * @param alpha   alpha transparancy in the range 0-1
+       * @returns {}
+       */
+      getCompositeColor: function (dest, src, alpha) {
+        var r = Math.floor(alpha * src[0] + (1 - alpha) * dest[0]),
+            g = Math.floor(alpha * src[1] + (1 - alpha) * dest[1]),
+            b = Math.floor(alpha * src[2] + (1 - alpha) * dest[2]);
+        return "rgb(" + r + "," + g + "," + b + ")";
+      },
+      createColorString: function (str) {
+        // Excel will quote color strings, strip all quotes
+        str = stripQuotes(str);
+
+        if (str.includes(",")) {
+          return str.startsWith("rgb") ? str : "rgb(" + str + ")";
+        } else {
+          return str;
+        }
+      },
+      darkenLighten: function (color, amt) {
+        let src;
+        let hexColor = this.colorNameToHex(color);
+
+        if (hexColor) {
+          src = IGVColor.hexToRgb(hexColor);
+        } else {
+          src = color.startsWith('rgb(') ? color : IGVColor.hexToRgb(color);
+        }
+
+        const components = src.replace(")", "").substring(4).split(",");
+        const r = Math.max(0, Math.min(255, Number.parseInt(components[0].trim()) + amt));
+        const g = Math.max(0, Math.min(255, Number.parseInt(components[1].trim()) + amt));
+        const b = Math.max(0, Math.min(255, Number.parseInt(components[2].trim()) + amt));
+        return 'rgb(' + r.toString() + ',' + g.toString() + ',' + b.toString() + ')';
+      },
+
+      /**
+       * Convert html/css color name to hex value.  Adapted from https://gist.github.com/mxfh/4719348
+       * @param colorName
+       * @returns {*}
+       */
+      colorNameToHex: function (colorName) {
+        // color list from http://stackoverflow.com/q/1573053/731179  with added gray/gray
+        const definedColorNames = {
+          "aliceblue": "#f0f8ff",
+          "antiquewhite": "#faebd7",
+          "aqua": "#00ffff",
+          "aquamarine": "#7fffd4",
+          "azure": "#f0ffff",
+          "beige": "#f5f5dc",
+          "bisque": "#ffe4c4",
+          "black": "#000000",
+          "blanchedalmond": "#ffebcd",
+          "blue": "#0000ff",
+          "blueviolet": "#8a2be2",
+          "brown": "#a52a2a",
+          "burlywood": "#deb887",
+          "cadetblue": "#5f9ea0",
+          "chartreuse": "#7fff00",
+          "chocolate": "#d2691e",
+          "coral": "#ff7f50",
+          "cornflowerblue": "#6495ed",
+          "cornsilk": "#fff8dc",
+          "crimson": "#dc143c",
+          "cyan": "#00ffff",
+          "darkblue": "#00008b",
+          "darkcyan": "#008b8b",
+          "darkgoldenrod": "#b8860b",
+          "darkgray": "#a9a9a9",
+          "darkgreen": "#006400",
+          "darkkhaki": "#bdb76b",
+          "darkmagenta": "#8b008b",
+          "darkolivegreen": "#556b2f",
+          "darkorange": "#ff8c00",
+          "darkorchid": "#9932cc",
+          "darkred": "#8b0000",
+          "darksalmon": "#e9967a",
+          "darkseagreen": "#8fbc8f",
+          "darkslateblue": "#483d8b",
+          "darkslategray": "#2f4f4f",
+          "darkturquoise": "#00ced1",
+          "darkviolet": "#9400d3",
+          "deeppink": "#ff1493",
+          "deepskyblue": "#00bfff",
+          "dimgray": "#696969",
+          "dodgerblue": "#1e90ff",
+          "firebrick": "#b22222",
+          "floralwhite": "#fffaf0",
+          "forestgreen": "#228b22",
+          "fuchsia": "#ff00ff",
+          "gainsboro": "#dcdcdc",
+          "ghostwhite": "#f8f8ff",
+          "gold": "#ffd700",
+          "goldenrod": "#daa520",
+          "gray": "#808080",
+          "green": "#008000",
+          "greenyellow": "#adff2f",
+          "honeydew": "#f0fff0",
+          "hotpink": "#ff69b4",
+          "indianred ": "#cd5c5c",
+          "indigo ": "#4b0082",
+          "ivory": "#fffff0",
+          "khaki": "#f0e68c",
+          "lavender": "#e6e6fa",
+          "lavenderblush": "#fff0f5",
+          "lawngreen": "#7cfc00",
+          "lemonchiffon": "#fffacd",
+          "lightblue": "#add8e6",
+          "lightcoral": "#f08080",
+          "lightcyan": "#e0ffff",
+          "lightgoldenrodyellow": "#fafad2",
+          "lightgrey": "#d3d3d3",
+          "lightgreen": "#90ee90",
+          "lightpink": "#ffb6c1",
+          "lightsalmon": "#ffa07a",
+          "lightseagreen": "#20b2aa",
+          "lightskyblue": "#87cefa",
+          "lightslategray": "#778899",
+          "lightsteelblue": "#b0c4de",
+          "lightyellow": "#ffffe0",
+          "lime": "#00ff00",
+          "limegreen": "#32cd32",
+          "linen": "#faf0e6",
+          "magenta": "#ff00ff",
+          "maroon": "#800000",
+          "mediumaquamarine": "#66cdaa",
+          "mediumblue": "#0000cd",
+          "mediumorchid": "#ba55d3",
+          "mediumpurple": "#9370d8",
+          "mediumseagreen": "#3cb371",
+          "mediumslateblue": "#7b68ee",
+          "mediumspringgreen": "#00fa9a",
+          "mediumturquoise": "#48d1cc",
+          "mediumvioletred": "#c71585",
+          "midnightblue": "#191970",
+          "mintcream": "#f5fffa",
+          "mistyrose": "#ffe4e1",
+          "moccasin": "#ffe4b5",
+          "navajowhite": "#ffdead",
+          "navy": "#000080",
+          "oldlace": "#fdf5e6",
+          "olive": "#808000",
+          "olivedrab": "#6b8e23",
+          "orange": "#ffa500",
+          "orangered": "#ff4500",
+          "orchid": "#da70d6",
+          "palegoldenrod": "#eee8aa",
+          "palegreen": "#98fb98",
+          "paleturquoise": "#afeeee",
+          "palevioletred": "#d87093",
+          "papayawhip": "#ffefd5",
+          "peachpuff": "#ffdab9",
+          "peru": "#cd853f",
+          "pink": "#ffc0cb",
+          "plum": "#dda0dd",
+          "powderblue": "#b0e0e6",
+          "purple": "#800080",
+          "red": "#ff0000",
+          "rosybrown": "#bc8f8f",
+          "royalblue": "#4169e1",
+          "saddlebrown": "#8b4513",
+          "salmon": "#fa8072",
+          "sandybrown": "#f4a460",
+          "seagreen": "#2e8b57",
+          "seashell": "#fff5ee",
+          "sienna": "#a0522d",
+          "silver": "#c0c0c0",
+          "skyblue": "#87ceeb",
+          "slateblue": "#6a5acd",
+          "slategray": "#708090",
+          "snow": "#fffafa",
+          "springgreen": "#00ff7f",
+          "steelblue": "#4682b4",
+          "tan": "#d2b48c",
+          "teal": "#008080",
+          "thistle": "#d8bfd8",
+          "tomato": "#ff6347",
+          "turquoise": "#40e0d0",
+          "violet": "#ee82ee",
+          "wheat": "#f5deb3",
+          "white": "#ffffff",
+          "whitesmoke": "#f5f5f5",
+          "yellow": "#ffff00",
+          "yellowgreen": "#9acd32",
+          "darkgrey": "#a9a9a9",
+          "darkslategrey": "#2f4f4f",
+          "dimgrey": "#696969",
+          "grey": "#808080",
+          "lightgray": "#d3d3d3",
+          "lightslategrey": "#778899",
+          "slategrey": "#708090"
+        };
+        return definedColorNames[colorName];
+      }
+    };
+
+    /**
+     * Make the target element movable by clicking and dragging on the handle.  This is not a general purprose function,
+     * it makes several options specific to igv dialogs, the primary one being that the
+     * target is absolutely positioned in pixel coordinates
+
+     */
+    let dragData$1; // Its assumed we are only dragging one element at a time.
+
+    function makeDraggable$1(target, handle) {
+      handle.addEventListener('mousedown', dragStart$1.bind(target));
+    }
+
+    function dragStart$1(event) {
+      event.stopPropagation();
+      event.preventDefault();
+      offset$1(this);
+      const dragFunction = drag$1.bind(this);
+      const dragEndFunction = dragEnd$1.bind(this);
+      const computedStyle = getComputedStyle(this);
+      const top = parseInt(computedStyle.top.replace("px", ""));
+      const left = parseInt(computedStyle.left.replace("px", ""));
+      dragData$1 = {
+        dragFunction: dragFunction,
+        dragEndFunction: dragEndFunction,
+        screenX: event.screenX,
+        screenY: event.screenY,
+        top: top,
+        left: left
+      };
+      document.addEventListener('mousemove', dragFunction);
+      document.addEventListener('mouseup', dragEndFunction);
+      document.addEventListener('mouseleave', dragEndFunction);
+      document.addEventListener('mouseexit', dragEndFunction);
+    }
+
+    function drag$1(event) {
+      if (!dragData$1) {
+        return;
+      }
+
+      event.stopPropagation();
+      event.preventDefault();
+      const dx = event.screenX - dragData$1.screenX;
+      const dy = event.screenY - dragData$1.screenY;
+      this.style.left = `${dragData$1.left + dx}px`;
+      this.style.top = `${dragData$1.top + dy}px`;
+    }
+
+    function dragEnd$1(event) {
+      if (!dragData$1) {
+        return;
+      }
+
+      event.stopPropagation();
+      event.preventDefault();
+      const dragFunction = dragData$1.dragFunction;
+      const dragEndFunction = dragData$1.dragEndFunction;
+      document.removeEventListener('mousemove', dragFunction);
+      document.removeEventListener('mouseup', dragEndFunction);
+      document.removeEventListener('mouseleave', dragEndFunction);
+      document.removeEventListener('mouseexit', dragEndFunction);
+      dragData$1 = undefined;
+    }
+
+    // Support for oauth token based authorization
+    // This class supports explicit setting of an oauth token either globally or for specific hosts.
+    //
+    // The variable oauth.google.access_token, which becomes igv.oauth.google.access_token on ES5 conversion is
+    // supported for backward compatibility
+    const DEFAULT_HOST = "googleapis";
+    const oauth = {
+      oauthTokens: {},
+      setToken: function (token, host) {
+        host = host || DEFAULT_HOST;
+        this.oauthTokens[host] = token;
+
+        if (host === DEFAULT_HOST) {
+          this.google.access_token = token; // legacy support
+        }
+      },
+      getToken: function (host) {
+        host = host || DEFAULT_HOST;
+        let token;
+
+        for (let key of Object.keys(this.oauthTokens)) {
+          const regex = wildcardToRegExp(key);
+
+          if (regex.test(host)) {
+            token = this.oauthTokens[key];
+            break;
+          }
+        }
+
+        return token;
+      },
+      removeToken: function (host) {
+        host = host || DEFAULT_HOST;
+
+        for (let key of Object.keys(this.oauthTokens)) {
+          const regex = wildcardToRegExp(key);
+
+          if (regex.test(host)) {
+            this.oauthTokens[key] = undefined;
+          }
+        }
+
+        if (host === DEFAULT_HOST) {
+          this.google.access_token = undefined; // legacy support
+        }
+      },
+      // Special object for google -- legacy support
+      google: {
+        setToken: function (token) {
+          oauth.setToken(token);
+        }
+      }
+    };
+    /**
+     * Creates a RegExp from the given string, converting asterisks to .* expressions,
+     * and escaping all other characters.
+     *
+     * credit https://gist.github.com/donmccurdy/6d073ce2c6f3951312dfa45da14a420f
+     */
+
+    function wildcardToRegExp(s) {
+      return new RegExp('^' + s.split(/\*+/).map(regExpEscape).join('.*') + '$');
+    }
+    /**
+     * RegExp-escapes all characters in the given string.
+     *
+     * credit https://gist.github.com/donmccurdy/6d073ce2c6f3951312dfa45da14a420f
+     */
+
+
+    function regExpEscape(s) {
+      return s.replace(/[|\\{}()[\]^$+*?.]/g, '\\$&');
+    }
+
+    // The MIT License (MIT)
+    /**
+     * @constructor
+     * @param {Object} options A set op options to pass to the throttle function
+     *        @param {number} requestsPerSecond The amount of requests per second
+     *                                          the library will limit to
+     */
+
+    class Throttle$1 {
+      constructor(options) {
+        this.requestsPerSecond = options.requestsPerSecond || 10;
+        this.lastStartTime = 0;
+        this.queued = [];
+      }
+      /**
+       * Adds a promise
+       * @param {Function} async function to be executed
+       * @param {Object} options A set of options.
+       * @return {Promise} A promise
+       */
+
+
+      add(asyncFunction, options) {
+        var self = this;
+        return new Promise(function (resolve, reject) {
+          self.queued.push({
+            resolve: resolve,
+            reject: reject,
+            asyncFunction: asyncFunction
+          });
+          self.dequeue();
+        });
+      }
+      /**
+       * Adds all the promises passed as parameters
+       * @param {Function} promises An array of functions that return a promise
+       * @param {Object} options A set of options.
+       * @param {number} options.signal An AbortSignal object that can be used to abort the returned promise
+       * @param {number} options.weight A "weight" of each operation resolving by array of promises
+       * @return {Promise} A promise that succeeds when all the promises passed as options do
+       */
+
+
+      addAll(promises, options) {
+        var addedPromises = promises.map(function (promise) {
+          return this.add(promise, options);
+        }.bind(this));
+        return Promise.all(addedPromises);
+      }
+
+      /**
+       * Dequeues a promise
+       * @return {void}
+       */
+      dequeue() {
+        if (this.queued.length > 0) {
+          var now = new Date(),
+              inc = 1000 / this.requestsPerSecond + 1,
+              elapsed = now - this.lastStartTime;
+
+          if (elapsed >= inc) {
+            this._execute();
+          } else {
+            // we have reached the limit, schedule a dequeue operation
+            setTimeout(function () {
+              this.dequeue();
+            }.bind(this), inc - elapsed);
+          }
+        }
+      }
+      /**
+       * Executes the promise
+       * @private
+       * @return {void}
+       */
+
+
+      async _execute() {
+        this.lastStartTime = new Date();
+        var candidate = this.queued.shift();
+        const f = candidate.asyncFunction;
+
+        try {
+          const r = await f();
+          candidate.resolve(r);
+        } catch (e) {
+          candidate.reject(e);
+        }
+      }
+
+    }
+
+    /*
+     * The MIT License (MIT)
+     *
+     * Copyright (c) 2014 Broad Institute
+     *
+     * Permission is hereby granted, free of charge, to any person obtaining a copy
+     * of this software and associated documentation files (the "Software"), to deal
+     * in the Software without restriction, including without limitation the rights
+     * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+     * copies of the Software, and to permit persons to whom the Software is
+     * furnished to do so, subject to the following conditions:
+     *
+     * The above copyright notice and this permission notice shall be included in
+     * all copies or substantial portions of the Software.
+     *
+     *
+     * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+     * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+     * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+     * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+     * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+     * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+     * THE SOFTWARE.
+     */
+    var NONE = 0;
+    var GZIP = 1;
+    var BGZF = 2;
+    var UNKNOWN = 3;
+    let RANGE_WARNING_GIVEN = false;
+    const googleThrottle = new Throttle$1({
+      requestsPerSecond: 8
+    });
+    const igvxhr = {
+      apiKey: undefined,
+      setApiKey: function (key) {
+        this.apiKey = key;
+      },
+      load: load,
+      loadArrayBuffer: async function (url, options) {
+        options = options || {};
+
+        if (!options.responseType) {
+          options.responseType = "arraybuffer";
+        }
+
+        if (url instanceof File) {
+          return loadFileSlice(url, options);
+        } else {
+          return load(url, options);
+        }
+      },
+      loadJson: async function (url, options) {
+        options = options || {};
+        const method = options.method || (options.sendData ? "POST" : "GET");
+
+        if (method === "POST") {
+          options.contentType = "application/json";
+        }
+
+        const result = await this.loadString(url, options);
+
+        if (result) {
+          return JSON.parse(result);
+        } else {
+          return result;
+        }
+      },
+      loadString: async function (path, options) {
+        options = options || {};
+
+        if (path instanceof File) {
+          return loadStringFromFile(path, options);
+        } else {
+          return loadStringFromUrl(path, options);
+        }
+      }
+    };
+
+    async function load(url, options) {
+      options = options || {};
+      const urlType = typeof url; // Resolve functions, promises, and functions that return promises
+
+      url = await (typeof url === 'function' ? url() : url);
+
+      if (url instanceof File) {
+        return loadFileSlice(url, options);
+      } else if (typeof url.startsWith === 'function') {
+        // Test for string
+        if (url.startsWith("data:")) {
+          return decodeDataURI$1(url);
+        } else {
+          if (url.startsWith("https://drive.google.com")) {
+            url = driveDownloadURL(url);
+          }
+
+          if (isGoogleDriveURL(url) || url.startsWith("https://www.dropbox.com")) {
+            return googleThrottle.add(async function () {
+              return loadURL(url, options);
+            });
+          } else {
+            return loadURL(url, options);
+          }
+        }
+      } else {
+        throw Error(`url must be either a 'File', 'string', 'function', or 'Promise'.  Actual type: ${urlType}`);
+      }
+    }
+
+    async function loadURL(url, options) {
+      //console.log(`${Date.now()}   ${url}`)
+      url = mapUrl(url);
+      options = options || {};
+      let oauthToken = options.oauthToken || getOauthToken(url);
+
+      if (oauthToken) {
+        oauthToken = await (typeof oauthToken === 'function' ? oauthToken() : oauthToken);
+      }
+
+      return new Promise(function (resolve, reject) {
+        // Various Google tansformations
+        if (isGoogleURL(url)) {
+          if (isGoogleStorageURL(url)) {
+            url = translateGoogleCloudURL(url);
+          }
+
+          url = addApiKey(url);
+
+          if (isGoogleDriveURL(url)) {
+            addTeamDrive(url);
+          } // If we have an access token try it, but don't force a signIn or request for scopes yet
+
+
+          if (!oauthToken) {
+            oauthToken = getCurrentGoogleAccessToken();
+          }
+        }
+
+        const headers = options.headers || {};
+
+        if (oauthToken) {
+          addOauthHeaders(headers, oauthToken);
+        }
+
+        const range = options.range;
+        const isChrome = navigator.userAgent.indexOf('Chrome') > -1;
+        navigator.vendor.indexOf("Apple") === 0 && /\sSafari\//.test(navigator.userAgent);
+
+        if (range && isChrome && !isAmazonV4Signed(url)) {
+          // Hack to prevent caching for byte-ranges. Attempt to fix net:err-cache errors in Chrome
+          url += url.includes("?") ? "&" : "?";
+          url += "someRandomSeed=" + Math.random().toString(36);
+        }
+
+        const xhr = new XMLHttpRequest();
+        const sendData = options.sendData || options.body;
+        const method = options.method || (sendData ? "POST" : "GET");
+        const responseType = options.responseType;
+        const contentType = options.contentType;
+        const mimeType = options.mimeType;
+        xhr.open(method, url);
+
+        if (options.timeout) {
+          xhr.timeout = options.timeout;
+        }
+
+        if (range) {
+          var rangeEnd = range.size ? range.start + range.size - 1 : "";
+          xhr.setRequestHeader("Range", "bytes=" + range.start + "-" + rangeEnd); //      xhr.setRequestHeader("Cache-Control", "no-cache");    <= This can cause CORS issues, disabled for now
+        }
+
+        if (contentType) {
+          xhr.setRequestHeader("Content-Type", contentType);
+        }
+
+        if (mimeType) {
+          xhr.overrideMimeType(mimeType);
+        }
+
+        if (responseType) {
+          xhr.responseType = responseType;
+        }
+
+        if (headers) {
+          for (let key of Object.keys(headers)) {
+            const value = headers[key];
+            xhr.setRequestHeader(key, value);
+          }
+        } // NOTE: using withCredentials with servers that return "*" for access-allowed-origin will fail
+
+
+        if (options.withCredentials === true) {
+          xhr.withCredentials = true;
+        }
+
+        xhr.onload = async function (event) {
+          // when the url points to a local file, the status is 0 but that is not an error
+          if (xhr.status === 0 || xhr.status >= 200 && xhr.status <= 300) {
+            if (range && xhr.status !== 206 && range.start !== 0) {
+              // 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 && !RANGE_WARNING_GIVEN) {
+                alert(`Warning: Range header ignored for URL: ${url}.  This can have performance impacts.`);
+              }
+
+              resolve(xhr.response.slice(range.start, range.start + range.size));
+            } else {
+              resolve(xhr.response);
+            }
+          } else if (typeof gapi !== "undefined" && (xhr.status === 404 || xhr.status === 401 || xhr.status === 403) && isGoogleURL(url) && !options.retries) {
+            tryGoogleAuth();
+          } else {
+            if (xhr.status === 403) {
+              handleError("Access forbidden: " + url);
+            } else if (xhr.status === 416) {
+              //  Tried to read off the end of the file.   This shouldn't happen, but if it does return an
+              handleError("Unsatisfiable range");
+            } else {
+              handleError(xhr.status);
+            }
+          }
+        };
+
+        xhr.onerror = function (event) {
+          if (isGoogleURL(url) && !options.retries) {
+            tryGoogleAuth();
+          }
+
+          handleError("Error accessing resource: " + url + " Status: " + xhr.status);
+        };
+
+        xhr.ontimeout = function (event) {
+          handleError("Timed out");
+        };
+
+        xhr.onabort = function (event) {
+          reject(event);
+        };
+
+        try {
+          xhr.send(sendData);
+        } catch (e) {
+          reject(e);
+        }
+
+        function handleError(error) {
+          if (reject) {
+            reject(error);
+          } else {
+            throw error;
+          }
+        }
+
+        async function tryGoogleAuth() {
+          try {
+            const accessToken = await fetchGoogleAccessToken(url);
+            options.retries = 1;
+            options.oauthToken = accessToken;
+            const response = await load(url, options);
+            resolve(response);
+          } catch (e) {
+            if (e.error) {
+              const msg = e.error.startsWith("popup_blocked") ? "Google login popup blocked by browser." : e.error;
+              alert(msg);
+            } else {
+              handleError(e);
+            }
+          }
+        }
+      });
+    }
+
+    async function loadFileSlice(localfile, options) {
+      let blob = options && options.range ? localfile.slice(options.range.start, options.range.start + options.range.size) : localfile;
+
+      if ("arraybuffer" === options.responseType) {
+        return blobToArrayBuffer(blob);
+      } else {
+        // binary string format, shouldn't be used anymore
+        return new Promise(function (resolve, reject) {
+          const fileReader = new FileReader();
+
+          fileReader.onload = function (e) {
+            resolve(fileReader.result);
+          };
+
+          fileReader.onerror = function (e) {
+            console.error("reject uploading local file " + localfile.name);
+            reject(null, fileReader);
+          };
+
+          fileReader.readAsBinaryString(blob);
+          console.warn("Deprecated method used: readAsBinaryString");
+        });
+      }
+    }
+
+    async function loadStringFromFile(localfile, options) {
+      const blob = options.range ? localfile.slice(options.range.start, options.range.start + options.range.size) : localfile;
+      let compression = NONE;
+
+      if (options && options.bgz || localfile.name.endsWith(".bgz")) {
+        compression = BGZF;
+      } else if (localfile.name.endsWith(".gz")) {
+        compression = GZIP;
+      }
+
+      if (compression === NONE) {
+        return blobToText(blob);
+      } else {
+        const arrayBuffer = await blobToArrayBuffer(blob);
+        return arrayBufferToString(arrayBuffer, compression);
+      }
+    }
+
+    async function blobToArrayBuffer(blob) {
+      if (typeof blob.arrayBuffer === 'function') {
+        return blob.arrayBuffer();
+      }
+
+      return new Promise(function (resolve, reject) {
+        const fileReader = new FileReader();
+
+        fileReader.onload = function (e) {
+          resolve(fileReader.result);
+        };
+
+        fileReader.onerror = function (e) {
+          console.error("reject uploading local file " + localfile.name);
+          reject(null, fileReader);
+        };
+
+        fileReader.readAsArrayBuffer(blob);
+      });
+    }
+
+    async function blobToText(blob) {
+      if (typeof blob.text === 'function') {
+        return blob.text();
+      }
+
+      return new Promise(function (resolve, reject) {
+        const fileReader = new FileReader();
+
+        fileReader.onload = function (e) {
+          resolve(fileReader.result);
+        };
+
+        fileReader.onerror = function (e) {
+          console.error("reject uploading local file " + localfile.name);
+          reject(null, fileReader);
+        };
+
+        fileReader.readAsText(blob);
+      });
+    }
+
+    async function loadStringFromUrl(url, options) {
+      options = options || {};
+      const fn = options.filename || (await getFilename$1(url));
+      let compression = UNKNOWN;
+
+      if (options.bgz) {
+        compression = BGZF;
+      } else if (fn.endsWith(".gz")) {
+        compression = GZIP;
+      }
+
+      options.responseType = "arraybuffer";
+      const data = await igvxhr.load(url, options);
+      return arrayBufferToString(data, compression);
+    }
+
+    function isAmazonV4Signed(url) {
+      return url.indexOf("X-Amz-Signature") > -1;
+    }
+
+    function getOauthToken(url) {
+      // Google is the default provider, don't try to parse host for google URLs
+      const host = isGoogleURL(url) ? undefined : parseUri(url).host;
+      let token = oauth.getToken(host);
+
+      if (token) {
+        return token;
+      } else if (host === undefined) {
+        const googleToken = getCurrentGoogleAccessToken();
+
+        if (googleToken && googleToken.expires_at > Date.now()) {
+          return googleToken.access_token;
+        }
+      }
+    }
+    /**
+     * Return a Google oAuth token, triggering a sign in if required.   This method should not be called until we know
+     * a token is required, that is until we've tried the url and received a 401, 403, or 404.
+     *
+     * @param url
+     * @returns the oauth token
+     */
+
+
+    async function fetchGoogleAccessToken(url) {
+      if (isInitialized()) {
+        const scope = getScopeForURL(url);
+        const googleToken = await getAccessToken(scope);
+        return googleToken ? googleToken.access_token : undefined;
+      } else {
+        throw Error(`Authorization is required, but Google oAuth has not been initalized. Contact your site administrator for assistance.`);
+      }
+    }
+    /**
+     * Return the current google access token, if one exists.  Do not triger signOn or request additional scopes.
+     * @returns {undefined|access_token}
+     */
+
+
+    function getCurrentGoogleAccessToken() {
+      if (isInitialized()) {
+        const googleToken = getCurrentAccessToken();
+        return googleToken ? googleToken.access_token : undefined;
+      } else {
+        return undefined;
+      }
+    }
+
+    function addOauthHeaders(headers, acToken) {
+      if (acToken) {
+        headers["Cache-Control"] = "no-cache";
+        headers["Authorization"] = "Bearer " + acToken;
+      }
+
+      return headers;
+    }
+
+    function addApiKey(url) {
+      let apiKey = igvxhr.apiKey;
+
+      if (!apiKey && typeof gapi !== "undefined") {
+        apiKey = gapi.apiKey;
+      }
+
+      if (apiKey !== undefined && !url.includes("key=")) {
+        const paramSeparator = url.includes("?") ? "&" : "?";
+        url = url + paramSeparator + "key=" + apiKey;
+      }
+
+      return url;
+    }
+
+    function addTeamDrive(url) {
+      if (url.includes("supportsTeamDrive")) {
+        return url;
+      } else {
+        const paramSeparator = url.includes("?") ? "&" : "?";
+        url = url + paramSeparator + "supportsTeamDrive=true";
+      }
+    }
+    /**
+     * Perform some well-known url mappings.
+     * @param url
+     */
+
+
+    function mapUrl(url) {
+      if (url.includes("//www.dropbox.com")) {
+        return url.replace("//www.dropbox.com", "//dl.dropboxusercontent.com");
+      } else if (url.includes("//drive.google.com")) {
+        return driveDownloadURL(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")) {
+        return url.replace("//igvdata.broadinstitute.org", "https://dn7ywbm9isq8j.cloudfront.net");
+      } else if (url.startsWith("ftp://ftp.ncbi.nlm.nih.gov/geo")) {
+        return url.replace("ftp://", "https://");
+      } else {
+        return url;
+      }
+    }
+
+    function arrayBufferToString(arraybuffer, compression) {
+      if (compression === UNKNOWN && arraybuffer.byteLength > 2) {
+        const m = new Uint8Array(arraybuffer, 0, 2);
+
+        if (m[0] === 31 && m[1] === 139) {
+          compression = GZIP;
+        }
+      }
+
+      let plain;
+
+      if (compression === GZIP) {
+        const inflate = new Zlib$1.Gunzip(new Uint8Array(arraybuffer));
+        plain = inflate.decompress();
+      } else if (compression === BGZF) {
+        plain = unbgzf(arraybuffer);
+      } else {
+        plain = new Uint8Array(arraybuffer);
+      }
+
+      if ('TextDecoder' in getGlobalObject()) {
+        return new TextDecoder().decode(plain);
+      } else {
+        return decodeUTF8(plain);
+      }
+    }
+    /**
+     * Use when TextDecoder is not available (primarily IE).
+     *
+     * From: https://gist.github.com/Yaffle/5458286
+     *
+     * @param octets
+     * @returns {string}
+     */
+
+
+    function decodeUTF8(octets) {
+      var string = "";
+      var i = 0;
+
+      while (i < octets.length) {
+        var octet = octets[i];
+        var bytesNeeded = 0;
+        var codePoint = 0;
+
+        if (octet <= 0x7F) {
+          bytesNeeded = 0;
+          codePoint = octet & 0xFF;
+        } else if (octet <= 0xDF) {
+          bytesNeeded = 1;
+          codePoint = octet & 0x1F;
+        } else if (octet <= 0xEF) {
+          bytesNeeded = 2;
+          codePoint = octet & 0x0F;
+        } else if (octet <= 0xF4) {
+          bytesNeeded = 3;
+          codePoint = octet & 0x07;
+        }
+
+        if (octets.length - i - bytesNeeded > 0) {
+          var k = 0;
+
+          while (k < bytesNeeded) {
+            octet = octets[i + k + 1];
+            codePoint = codePoint << 6 | octet & 0x3F;
+            k += 1;
+          }
+        } else {
+          codePoint = 0xFFFD;
+          bytesNeeded = octets.length - i;
+        }
+
+        string += String.fromCodePoint(codePoint);
+        i += bytesNeeded + 1;
+      }
+
+      return string;
+    }
+
+    function getGlobalObject() {
+      if (typeof self !== 'undefined') {
+        return self;
+      }
+
+      if (typeof global !== 'undefined') {
+        return global;
+      } else {
+        return window;
+      }
+    }
+
+    async function getFilename$1(url) {
+      if (isString$6(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);
+      }
+    }
+
+    /*
+     * The MIT License (MIT)
+     *
+     * Copyright (c) 2014 Broad Institute
+     *
+     * Permission is hereby granted, free of charge, to any person obtaining a copy
+     * of this software and associated documentation files (the "Software"), to deal
+     * in the Software without restriction, including without limitation the rights
+     * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+     * copies of the Software, and to permit persons to whom the Software is
+     * furnished to do so, subject to the following conditions:
+     *
+     * The above copyright notice and this permission notice shall be included in
+     * all copies or substantial portions of the Software.
+     *
+     *
+     * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+     * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+     * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+     * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+     * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+     * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+     * THE SOFTWARE.
+     */
+
+    /** An implementation of an interval tree, following the explanation.
+     * from CLR.
+     *
+     * Public interface:
+     *   Constructor  IntervalTree
+     *   Insertion    insert
+     *   Search       findOverlapping
+     */
+    var BLACK = 1;
+    var RED = 2;
+    var NIL = {};
+    NIL.color = BLACK;
+    NIL.parent = NIL;
+    NIL.left = NIL;
+    NIL.right = NIL;
+
+    class IntervalTree {
+      constructor() {
+        this.root = NIL;
+      }
+
+      insert(start, end, value) {
+        var interval = new Interval(start, end, value);
+        var x = new Node(interval);
+        this.treeInsert(x);
+        x.color = RED;
+
+        while (x !== this.root && x.parent.color === RED) {
+          if (x.parent === x.parent.parent.left) {
+            let y = x.parent.parent.right;
+
+            if (y.color === RED) {
+              x.parent.color = BLACK;
+              y.color = BLACK;
+              x.parent.parent.color = RED;
+              x = x.parent.parent;
+            } else {
+              if (x === x.parent.right) {
+                x = x.parent;
+                leftRotate.call(this, x);
+              }
+
+              x.parent.color = BLACK;
+              x.parent.parent.color = RED;
+              rightRotate.call(this, x.parent.parent);
+            }
+          } else {
+            let y = x.parent.parent.left;
+
+            if (y.color === RED) {
+              x.parent.color = BLACK;
+              y.color = BLACK;
+              x.parent.parent.color = RED;
+              x = x.parent.parent;
+            } else {
+              if (x === x.parent.left) {
+                x = x.parent;
+                rightRotate.call(this, x);
+              }
+
+              x.parent.color = BLACK;
+              x.parent.parent.color = RED;
+              leftRotate.call(this, x.parent.parent);
+            }
+          }
+        }
+
+        this.root.color = BLACK;
+      }
+      /**
+       *
+       * @param start - query interval
+       * @param end - query interval
+       * @returns Array of all intervals overlapping the query region
+       */
+
+
+      findOverlapping(start, end) {
+        var searchInterval = new Interval(start, end, 0);
+        if (this.root === NIL) return [];
+        var intervals = searchAll.call(this, searchInterval, this.root, []);
+
+        if (intervals.length > 1) {
+          intervals.sort(function (i1, i2) {
+            return i1.low - i2.low;
+          });
+        }
+
+        return intervals;
+      }
+      /**
+       * Dump info on intervals to console.  For debugging.
+       */
+
+
+      logIntervals() {
+        logNode(this.root);
+
+        function logNode(node, indent) {
+          if (node.left !== NIL) logNode(node.left);
+          if (node.right !== NIL) logNode(node.right);
+        }
+      }
+
+      mapIntervals(func) {
+        applyInterval(this.root);
+
+        function applyInterval(node) {
+          func(node.interval);
+          if (node.left !== NIL) applyInterval(node.left);
+          if (node.right !== NIL) applyInterval(node.right);
+        }
+      }
+      /**
+       * Note:  Does not maintain RB constraints,  this is done post insert
+       *
+       * @param x  a Node
+       */
+
+
+      treeInsert(x) {
+        var node = this.root;
+        var y = NIL;
+
+        while (node !== NIL) {
+          y = node;
+
+          if (x.interval.low <= node.interval.low) {
+            node = node.left;
+          } else {
+            node = node.right;
+          }
+        }
+
+        x.parent = y;
+
+        if (y === NIL) {
+          this.root = x;
+          x.left = x.right = NIL;
+        } else {
+          if (x.interval.low <= y.interval.low) {
+            y.left = x;
+          } else {
+            y.right = x;
+          }
+        }
+
+        applyUpdate.call(this, x);
+      }
+
+    }
+
+    function searchAll(interval, node, results) {
+      if (node.interval.overlaps(interval)) {
+        results.push(node.interval);
+      }
+
+      if (node.left !== NIL && node.left.max >= interval.low) {
+        searchAll.call(this, interval, node.left, results);
+      }
+
+      if (node.right !== NIL && node.right.min <= interval.high) {
+        searchAll.call(this, interval, node.right, results);
+      }
+
+      return results;
+    }
+
+    function leftRotate(x) {
+      var y = x.right;
+      x.right = y.left;
+
+      if (y.left !== NIL) {
+        y.left.parent = x;
+      }
+
+      y.parent = x.parent;
+
+      if (x.parent === NIL) {
+        this.root = y;
+      } else {
+        if (x.parent.left === x) {
+          x.parent.left = y;
+        } else {
+          x.parent.right = y;
+        }
+      }
+
+      y.left = x;
+      x.parent = y;
+      applyUpdate.call(this, x); // no need to apply update on y, since it'll y is an ancestor
+      // of x, and will be touched by applyUpdate().
+    }
+
+    function rightRotate(x) {
+      var y = x.left;
+      x.left = y.right;
+
+      if (y.right !== NIL) {
+        y.right.parent = x;
+      }
+
+      y.parent = x.parent;
+
+      if (x.parent === NIL) {
+        this.root = y;
+      } else {
+        if (x.parent.right === x) {
+          x.parent.right = y;
+        } else {
+          x.parent.left = y;
+        }
+      }
+
+      y.right = x;
+      x.parent = y;
+      applyUpdate.call(this, x); // no need to apply update on y, since it'll y is an ancestor
+      // of x, and will be touched by applyUpdate().
+    } // Applies the statistic update on the node and its ancestors.
+
+
+    function applyUpdate(node) {
+      while (node !== NIL) {
+        var nodeMax = node.left.max > node.right.max ? node.left.max : node.right.max;
+        var intervalHigh = node.interval.high;
+        node.max = nodeMax > intervalHigh ? nodeMax : intervalHigh;
+        var nodeMin = node.left.min < node.right.min ? node.left.min : node.right.min;
+        var intervalLow = node.interval.low;
+        node.min = nodeMin < intervalLow ? nodeMin : intervalLow;
+        node = node.parent;
+      }
+    }
+
+    class Interval {
+      constructor(low, high, value) {
+        this.low = low;
+        this.high = high;
+        this.value = value;
+      }
+
+      equals(other) {
+        if (!other) {
+          return false;
+        }
+
+        if (this === other) {
+          return true;
+        }
+
+        return this.low === other.low && this.high === other.high;
+      }
+
+      compareTo(other) {
+        if (this.low < other.low) return -1;
+        if (this.low > other.low) return 1;
+        if (this.high < other.high) return -1;
+        if (this.high > other.high) return 1;
+        return 0;
+      }
+      /**
+       * Returns true if this interval overlaps the other.
+       */
+
+
+      overlaps(other) {
+        return this.low <= other.high && other.low <= this.high;
+      }
+
+    }
+
+    function Node(interval) {
+      this.parent = NIL;
+      this.left = NIL;
+      this.right = NIL;
+      this.interval = interval;
+      this.color = RED;
+    } //
+
+    /*
+     * The MIT License (MIT)
+     *
+     * Copyright (c) 2014 Broad Institute
+     *
+     * Permission is hereby granted, free of charge, to any person obtaining a copy
+     * of this software and associated documentation files (the "Software"), to deal
+     * in the Software without restriction, including without limitation the rights
+     * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+     * copies of the Software, and to permit persons to whom the Software is
+     * furnished to do so, subject to the following conditions:
+     *
+     * The above copyright notice and this permission notice shall be included in
+     * all copies or substantial portions of the Software.
+     *
+     *
+     * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+     * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+     * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+     * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+     * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+     * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+     * THE SOFTWARE.
+     */
+    /**
+     * Object for caching lists of features.  Supports effecient queries for sub-range  (chr, start, end)
+     *
+     * @param featureList
+     * @param The genomic range spanned by featureList (optional)
+     * @constructor
+     */
+
+    class FeatureCache {
+      constructor(featureList, genome, range) {
+        featureList = featureList || [];
+        this.treeMap = this.buildTreeMap(featureList, genome);
+        this.range = range;
+        this.count = featureList.length;
+      }
+
+      containsRange(genomicRange) {
+        // No range means cache contains all features
+        return this.range === undefined || this.range.contains(genomicRange.chr, genomicRange.start, genomicRange.end);
+      }
+
+      queryFeatures(chr, start, end) {
+        const tree = this.treeMap[chr];
+        if (!tree) return [];
+        const intervals = tree.findOverlapping(start, end);
+
+        if (intervals.length === 0) {
+          return [];
+        } else {
+          // Trim the list of features in the intervals to those
+          // overlapping the requested range.
+          // Assumption: features are sorted by start position
+          const featureList = [];
+          const all = this.allFeatures[chr];
+
+          if (all) {
+            for (let interval of intervals) {
+              const indexRange = interval.value;
+
+              for (let i = indexRange.start; i < indexRange.end; i++) {
+                let feature = all[i];
+                if (feature.start > end) break;else if (feature.end >= start) {
+                  featureList.push(feature);
+                }
+              }
+            }
+
+            featureList.sort(function (a, b) {
+              return a.start - b.start;
+            });
+          }
+
+          return featureList;
+        }
+      }
+
+      /**
+       * Returns all features, unsorted.
+       *
+       * @returns {Array}
+       */
+      getAllFeatures() {
+        return this.allFeatures;
+      }
+
+      buildTreeMap(featureList, genome) {
+        const treeMap = {};
+        const chromosomes = [];
+        this.allFeatures = {};
+
+        if (featureList) {
+          for (let feature of featureList) {
+            let chr = feature.chr; // Translate to "official" name
+
+            if (genome) {
+              chr = genome.getChromosomeName(chr);
+            }
+
+            let geneList = this.allFeatures[chr];
+
+            if (!geneList) {
+              chromosomes.push(chr);
+              geneList = [];
+              this.allFeatures[chr] = geneList;
+            }
+
+            geneList.push(feature);
+          } // Now build interval tree for each chromosome
+
+
+          for (let chr of chromosomes) {
+            const chrFeatures = this.allFeatures[chr];
+            chrFeatures.sort(function (f1, f2) {
+              return f1.start === f2.start ? 0 : f1.start > f2.start ? 1 : -1;
+            });
+            treeMap[chr] = buildIntervalTree$1(chrFeatures);
+          }
+        }
+
+        return treeMap;
+      }
+
+    }
+    /**
+     * Build an interval tree from the feature list for fast interval based queries.   We lump features in groups
+     * of 10, or total size / 100,   to reduce size of the tree.
+     *
+     * @param featureList
+     */
+
+
+    function buildIntervalTree$1(featureList) {
+      const tree = new IntervalTree();
+      const len = featureList.length;
+      const chunkSize = Math.max(10, Math.round(len / 10));
+
+      for (let i = 0; i < len; i += chunkSize) {
+        const e = Math.min(len, i + chunkSize);
+        const subArray = new IndexRange(i, e); //featureList.slice(i, e);
+
+        const iStart = featureList[i].start; //
+
+        let iEnd = iStart;
+
+        for (let j = i; j < e; j++) {
+          iEnd = Math.max(iEnd, featureList[j].end);
+        }
+
+        tree.insert(iStart, iEnd, subArray);
+      }
+
+      return tree;
+    }
+
+    class IndexRange {
+      constructor(start, end) {
+        this.start = start;
+        this.end = end;
+      }
+
+    }
+
+    /*
+     * The MIT License (MIT)
+     *
+     * Copyright (c) 2016-2017 The Regents of the University of California
+     * Author: Jim Robinson
+     *
+     * Permission is hereby granted, free of charge, to any person obtaining a copy
+     * of this software and associated documentation files (the "Software"), to deal
+     * in the Software without restriction, including without limitation the rights
+     * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+     * copies of the Software, and to permit persons to whom the Software is
+     * furnished to do so, subject to the following conditions:
+     *
+     * The above copyright notice and this permission notice shall be included in
+     * all copies or substantial portions of the Software.
+     *
+     *
+     * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+     * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+     * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+     * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+     * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+     * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+     * THE SOFTWARE.
+     */
+    const FeatureUtils = {
+      packFeatures: function (features, maxRows, sorted) {
+        var start;
+        var end;
+        if (!features) return;
+        maxRows = maxRows || 10000;
+
+        if (!sorted) {
+          features.sort(function (a, b) {
+            return a.start - b.start;
+          });
+        }
+
+        if (features.length === 0) {
+          return [];
+        } else {
+          var bucketList = [],
+              allocatedCount = 0,
+              lastAllocatedCount = 0,
+              nextStart,
+              row,
+              index,
+              bucket,
+              feature,
+              gap = 2,
+              bucketStart;
+          start = features[0].start;
+          end = features[features.length - 1].start;
+          bucketStart = Math.max(start, features[0].start);
+          nextStart = bucketStart;
+          features.forEach(function (alignment) {
+            var buckListIndex = Math.max(0, alignment.start - bucketStart);
+
+            if (bucketList[buckListIndex] === undefined) {
+              bucketList[buckListIndex] = [];
+            }
+
+            bucketList[buckListIndex].push(alignment);
+          });
+          row = 0;
+
+          while (allocatedCount < features.length && row <= maxRows) {
+            while (nextStart <= end) {
+              bucket = undefined;
+
+              while (!bucket && nextStart <= end) {
+                index = nextStart - bucketStart;
+
+                if (bucketList[index] === undefined) {
+                  ++nextStart; // No buckets at this index
+                } else {
+                  bucket = bucketList[index];
+                }
+              } // while (bucket)
+
+
+              if (!bucket) {
+                break;
+              }
+
+              feature = bucket.pop();
+
+              if (0 === bucket.length) {
+                bucketList[index] = undefined;
+              }
+
+              feature.row = row;
+              nextStart = feature.end + gap;
+              ++allocatedCount;
+            } // while (nextStart)
+
+
+            row++;
+            nextStart = bucketStart;
+            if (allocatedCount === lastAllocatedCount) break; // Protect from infinite loops
+
+            lastAllocatedCount = allocatedCount;
+          } // while (allocatedCount)
+
+        }
+      },
+
+      /**
+       * Find features overlapping the given interval.  It is assumed that all features share the same chromosome.
+       *
+       * TODO -- significant overlap with FeatureCache, refactor to combine
+       *
+       * @param featureList
+       * @param start
+       * @param end
+       */
+      findOverlapping: function (featureList, start, end) {
+        if (!featureList || featureList.length === 0) {
+          return [];
+        } else {
+          const tree = buildIntervalTree(featureList);
+          const intervals = tree.findOverlapping(start, end);
+
+          if (intervals.length === 0) {
+            return [];
+          } else {
+            // Trim the list of features in the intervals to those
+            // overlapping the requested range.
+            // Assumption: features are sorted by start position
+            featureList = [];
+            intervals.forEach(function (interval) {
+              const intervalFeatures = interval.value;
+              const len = intervalFeatures.length;
+
+              for (let i = 0; i < len; i++) {
+                const feature = intervalFeatures[i];
+                if (feature.start > end) break;else if (feature.end > start) {
+                  featureList.push(feature);
+                }
+              }
+            });
+            featureList.sort(function (a, b) {
+              return a.start - b.start;
+            });
+            return featureList;
+          }
+        }
+      }
+    };
+    /**
+     * Build an interval tree from the feature list for fast interval based queries.   We lump features in groups
+     * of 10, or total size / 100,   to reduce size of the tree.
+     *
+     * @param featureList
+     */
+
+    function buildIntervalTree(featureList) {
+      const tree = new IntervalTree();
+      const len = featureList.length;
+      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;
+      });
+
+      for (let i = 0; i < len; i += chunkSize) {
+        const e = Math.min(len, i + chunkSize);
+        const subArray = featureList.slice(i, e);
+        const iStart = subArray[0].start;
+        let iEnd = iStart;
+        subArray.forEach(function (feature) {
+          iEnd = Math.max(iEnd, feature.end);
+        });
+        tree.insert(iStart, iEnd, subArray);
+      }
+
+      return tree;
+    }
+
+    function createCheckbox$1(name, initialState) {
+      const $container = $('<div>', {
+        class: 'igv-menu-popup-check-container'
+      });
+      const $div = $('<div>');
+      $container.append($div);
+      const svg = createIcon$2('check', true === initialState ? '#444' : 'transparent');
+      $div.append($(svg));
+      const $label = $('<div>'
+      /*, { class: 'igv-some-label-class' }*/
+      );
+      $label.text(name);
+      $container.append($label);
+      return $container;
+    }
+
+    function createIcon$1(name, color) {
+      return $(createIcon$2(name, color));
+    }
+
+    /**
+     * Configure item list for track "gear" menu.
+     * @param trackView
+     */
+
+    const MenuUtils = {
+      trackMenuItemList: function (trackView) {
+        const vizWindowTypes = new Set(['alignment', 'annotation', 'variant', 'eqtl', 'snp']);
+        const hasVizWindow = trackView.track.config && trackView.track.config.visibilityWindow !== undefined;
+        let menuItems = [];
+
+        if (trackView.track.config.type !== 'sequence') {
+          menuItems.push(trackRenameMenuItem(trackView));
+          menuItems.push(trackHeightMenuItem(trackView));
+        }
+
+        if (this.showColorPicker(trackView.track)) {
+          menuItems.push('<hr/>');
+          menuItems.push(colorPickerMenuItem({
+            trackView,
+            label: "Set track color",
+            option: "color"
+          }));
+          menuItems.push(unsetColorMenuItem({
+            trackView,
+            label: "Unset track color"
+          }));
+          menuItems.push(colorPickerMenuItem({
+            trackView,
+            label: "Set alt color",
+            option: "altColor"
+          }));
+        }
+
+        if (trackView.track.menuItemList) {
+          menuItems = menuItems.concat(trackView.track.menuItemList());
+        }
+
+        if (hasVizWindow || vizWindowTypes.has(trackView.track.type)) {
+          menuItems.push('<hr/>');
+          menuItems.push(visibilityWindowMenuItem(trackView));
+        }
+
+        if (trackView.track.removable !== false) {
+          menuItems.push('<hr/>');
+          menuItems.push(trackRemovalMenuItem(trackView));
+        }
+
+        return menuItems;
+      },
+      numericDataMenuItems: function (trackView) {
+        const menuItems = []; // Data range
+
+        const $e = $('<div>');
+        $e.text('Set data range');
+
+        const clickHandler = function () {
+          trackView.browser.dataRangeDialog.configure(trackView);
+          trackView.browser.dataRangeDialog.present($(trackView.trackDiv));
+        };
+
+        menuItems.push({
+          object: $e,
+          click: clickHandler
+        });
+
+        if (trackView.track.logScale !== undefined) {
+          menuItems.push({
+            object: createCheckbox$1("Log scale", trackView.track.logScale),
+            click: () => {
+              trackView.track.logScale = !trackView.track.logScale;
+              trackView.repaintViews();
+            }
+          });
+        }
+
+        menuItems.push({
+          object: createCheckbox$1("Autoscale", trackView.track.autoscale),
+          click: () => {
+            trackView.track.autoscale = !trackView.track.autoscale;
+            trackView.updateViews();
+          }
+        });
+        return menuItems;
+      },
+      trackMenuItemListHelper: function (itemList, $popover) {
+        var list = [];
+
+        if (itemList.length > 0) {
+          list = itemList.map(function (item, i) {
+            var $e; // name and object fields checked for backward compatibility
+
+            if (item.name) {
+              $e = $('<div>');
+              $e.text(item.name);
+            } else if (item.object) {
+              $e = item.object;
+            } else if (typeof item.label === 'string') {
+              $e = $('<div>');
+              $e.html(item.label);
+            } else if (typeof item === 'string') {
+              if (item.startsWith("<")) {
+                $e = $(item);
+              } else {
+                $e = $("<div>" + item + "</div>");
+              }
+            }
+
+            if (0 === i) {
+              $e.addClass('igv-track-menu-border-top');
+            }
+
+            if (item.click) {
+              $e.on('click', handleClick);
+              $e.on('touchend', function (e) {
+                handleClick(e);
+              });
+              $e.on('mouseup', function (e) {
+                e.preventDefault();
+                e.stopPropagation();
+              }); // eslint-disable-next-line no-inner-declarations
+
+              function handleClick(e) {
+                item.click(e);
+                $popover.hide();
+                e.preventDefault();
+                e.stopPropagation();
+              }
+            }
+
+            return {
+              object: $e,
+              init: item.init || undefined
+            };
+          });
+        }
+
+        return list;
+      },
+
+      showColorPicker(track) {
+        return undefined === track.type || "bedtype" === track.type || "alignment" === track.type || "annotation" === track.type || "variant" === track.type || "wig" === track.type;
+      }
+
+    };
+
+    function visibilityWindowMenuItem(trackView) {
+      const click = e => {
+        const callback = () => {
+          let value = trackView.browser.inputDialog.input.value;
+          value = '' === value || undefined === value ? -1 : value.trim();
+          trackView.track.visibilityWindow = Number.parseInt(value);
+          trackView.track.config.visibilityWindow = Number.parseInt(value);
+          trackView.updateViews();
+        };
+
+        const config = {
+          label: 'Visibility Window',
+          value: trackView.track.visibilityWindow,
+          callback
+        };
+        trackView.browser.inputDialog.present(config, e);
+      };
+
+      const object = $('<div>');
+      object.text('Set visibility window');
+      return {
+        object,
+        click
+      };
+    }
+
+    function trackRemovalMenuItem(trackView) {
+      var $e, menuClickHandler;
+      $e = $('<div>');
+      $e.text('Remove track');
+
+      menuClickHandler = function () {
+        trackView.browser.removeTrack(trackView.track);
+      };
+
+      return {
+        object: $e,
+        click: menuClickHandler
+      };
+    }
+
+    function colorPickerMenuItem({
+      trackView,
+      label,
+      option
+    }) {
+      const $e = $('<div>');
+      $e.text(label);
+      return {
+        object: $e,
+        click: () => trackView.presentColorPicker(option)
+      };
+    }
+
+    function unsetColorMenuItem({
+      trackView,
+      label
+    }) {
+      const $e = $('<div>');
+      $e.text(label);
+      return {
+        object: $e,
+        click: () => {
+          trackView.track.color = undefined;
+          trackView.repaintViews();
+        }
+      };
+    }
+
+    function trackRenameMenuItem(trackView) {
+      const click = e => {
+        const callback = function () {
+          let value = trackView.browser.inputDialog.input.value;
+          value = '' === value || undefined === value ? 'untitled' : value.trim();
+          trackView.browser.setTrackLabelName(trackView, value);
+        };
+
+        const config = {
+          label: 'Track Name',
+          value: getTrackLabelText(trackView.track) || 'unnamed',
+          callback
+        };
+        trackView.browser.inputDialog.present(config, e);
+      };
+
+      const object = $('<div>');
+      object.text('Set track name');
+      return {
+        object,
+        click
+      };
+    }
+
+    function trackHeightMenuItem(trackView) {
+      const click = e => {
+        const callback = () => {
+          const number = parseFloat(trackView.browser.inputDialog.input.value, 10);
+
+          if (undefined !== number) {
+            // If explicitly setting the height adust min or max, if neccessary.
+            if (trackView.track.minHeight !== undefined && trackView.track.minHeight > number) {
+              trackView.track.minHeight = number;
+            }
+
+            if (trackView.track.maxHeight !== undefined && trackView.track.maxHeight < number) {
+              trackView.track.minHeight = number;
+            }
+
+            trackView.setTrackHeight(number, true); // Explicitly setting track height turns off autoHeight
+
+            trackView.track.autoHeight = false;
+          }
+        };
+
+        const config = {
+          label: 'Track Height',
+          value: trackView.trackDiv.clientHeight,
+          callback
+        };
+        trackView.browser.inputDialog.present(config, e);
+      };
+
+      const object = $('<div>');
+      object.text('Set track height');
+      return {
+        object,
+        click
+      };
+    }
+
+    function getTrackLabelText(track) {
+      var vp, txt;
+      vp = track.trackView.viewports[0];
+      txt = vp.$trackLabel.text();
+      return txt;
+    }
+
+    function div(options) {
+      return create("div", options);
+    }
+
+    function create(tag, options) {
+      const elem = document.createElement(tag);
+
+      if (options) {
+        if (options.class) {
+          elem.classList.add(options.class);
+        }
+
+        if (options.id) {
+          elem.id = options.id;
+        }
+
+        if (options.style) {
+          applyStyle(elem, options.style);
+        }
+      }
+
+      return elem;
+    }
+
+    function hide(elem) {
+      const cssStyle = getComputedStyle(elem);
+
+      if (cssStyle.display !== "none") {
+        elem._initialDisplay = cssStyle.display;
+      }
+
+      elem.style.display = "none";
+    }
+
+    function show(elem) {
+      const currentDisplay = getComputedStyle(elem).display;
+
+      if (currentDisplay === "none") {
+        const d = elem._initialDisplay || "block";
+        elem.style.display = d;
+      }
+    }
+
+    function offset(elem) {
+      // Return zeros for disconnected and hidden (display: none) elements (gh-2310)
+      // Support: IE <=11 only
+      // Running getBoundingClientRect on a
+      // disconnected node in IE throws an error
+      if (!elem.getClientRects().length) {
+        return {
+          top: 0,
+          left: 0
+        };
+      } // Get document-relative position by adding viewport scroll to viewport-relative gBCR
+
+
+      const rect = elem.getBoundingClientRect();
+      const win = elem.ownerDocument.defaultView;
+      return {
+        top: rect.top + win.pageYOffset,
+        left: rect.left + win.pageXOffset
+      };
+    }
+
+    function pageCoordinates(e) {
+      if (e.type.startsWith("touch")) {
+        const touch = e.touches[0];
+        return {
+          x: touch.pageX,
+          y: touch.pageY
+        };
+      } else {
+        return {
+          x: e.pageX,
+          y: e.pageY
+        };
+      }
+    }
+
+    function applyStyle(elem, style) {
+      for (let key of Object.keys(style)) {
+        elem.style[key] = style[key];
+      }
+    }
+
+    let getMouseXY = (domElement, {
+      clientX,
+      clientY
+    }) => {
+      // DOMRect object with eight properties: left, top, right, bottom, x, y, width, height
+      const {
+        left,
+        top,
+        width,
+        height
+      } = domElement.getBoundingClientRect();
+      const x = clientX - left;
+      const y = clientY - top;
+      return {
+        x,
+        y,
+        xNormalized: x / width,
+        yNormalized: y / height,
+        width,
+        height
+      };
+    };
+    /**
+     * Translate the mouse coordinates for the event to the coordinates for the given target element
+     * @param event
+     * @param domElement
+     * @returns {{x: number, y: number}}
+     */
+
+
+    function translateMouseCoordinates(event, domElement) {
+      const {
+        clientX,
+        clientY
+      } = event;
+      return getMouseXY(domElement, {
+        clientX,
+        clientY
+      });
+    }
+
+    function createCheckbox(name, initialState) {
+      const container = div({
+        class: 'igv-ui-trackgear-popover-check-container'
+      });
+      const svg = iconMarkup('check', true === initialState ? '#444' : 'transparent');
+      svg.style.borderColor = 'gray';
+      svg.style.borderWidth = '1px';
+      svg.style.borderStyle = 'solid';
+      container.appendChild(svg);
+      let label = div(); //{ class: 'igv-some-label-class' });
+
+      label.textContent = name;
+      container.appendChild(label);
+      return container;
+    }
+
+    function createIcon(name, color) {
+      return iconMarkup(name, color);
+    }
+
+    function iconMarkup(name, color) {
+      color = color || "currentColor";
+      let icon = icons[name];
+
+      if (!icon) {
+        console.error(`No icon named: ${name}`);
+        icon = icons["question"];
+      }
+
+      const svg = document.createElementNS("http://www.w3.org/2000/svg", "svg");
+      svg.setAttributeNS(null, 'viewBox', '0 0 ' + icon[0] + ' ' + icon[1]);
+      const path = document.createElementNS("http://www.w3.org/2000/svg", "path");
+      path.setAttributeNS(null, 'fill', color);
+      path.setAttributeNS(null, 'd', icon[4]);
+      svg.appendChild(path);
+      return svg;
+    }
+
+    const icons = {
+      "check": [512, 512, [], "f00c", "M173.898 439.404l-166.4-166.4c-9.997-9.997-9.997-26.206 0-36.204l36.203-36.204c9.997-9.998 26.207-9.998 36.204 0L192 312.69 432.095 72.596c9.997-9.997 26.207-9.997 36.204 0l36.203 36.204c9.997 9.997 9.997 26.206 0 36.204l-294.4 294.401c-9.998 9.997-26.207 9.997-36.204-.001z"],
+      "cog": [512, 512, [], "f013", "M444.788 291.1l42.616 24.599c4.867 2.809 7.126 8.618 5.459 13.985-11.07 35.642-29.97 67.842-54.689 94.586a12.016 12.016 0 0 1-14.832 2.254l-42.584-24.595a191.577 191.577 0 0 1-60.759 35.13v49.182a12.01 12.01 0 0 1-9.377 11.718c-34.956 7.85-72.499 8.256-109.219.007-5.49-1.233-9.403-6.096-9.403-11.723v-49.184a191.555 191.555 0 0 1-60.759-35.13l-42.584 24.595a12.016 12.016 0 0 1-14.832-2.254c-24.718-26.744-43.619-58.944-54.689-94.586-1.667-5.366.592-11.175 5.459-13.985L67.212 291.1a193.48 193.48 0 0 1 0-70.199l-42.616-24.599c-4.867-2.809-7.126-8.618-5.459-13.985 11.07-35.642 29.97-67.842 54.689-94.586a12.016 12.016 0 0 1 14.832-2.254l42.584 24.595a191.577 191.577 0 0 1 60.759-35.13V25.759a12.01 12.01 0 0 1 9.377-11.718c34.956-7.85 72.499-8.256 109.219-.007 5.49 1.233 9.403 6.096 9.403 11.723v49.184a191.555 191.555 0 0 1 60.759 35.13l42.584-24.595a12.016 12.016 0 0 1 14.832 2.254c24.718 26.744 43.619 58.944 54.689 94.586 1.667 5.366-.592 11.175-5.459 13.985L444.788 220.9a193.485 193.485 0 0 1 0 70.2zM336 256c0-44.112-35.888-80-80-80s-80 35.888-80 80 35.888 80 80 80 80-35.888 80-80z"],
+      "exclamation": [192, 512, [], "f12a", "M176 432c0 44.112-35.888 80-80 80s-80-35.888-80-80 35.888-80 80-80 80 35.888 80 80zM25.26 25.199l13.6 272C39.499 309.972 50.041 320 62.83 320h66.34c12.789 0 23.331-10.028 23.97-22.801l13.6-272C167.425 11.49 156.496 0 142.77 0H49.23C35.504 0 24.575 11.49 25.26 25.199z"],
+      "exclamation-circle": [512, 512, [], "f06a", "M504 256c0 136.997-111.043 248-248 248S8 392.997 8 256C8 119.083 119.043 8 256 8s248 111.083 248 248zm-248 50c-25.405 0-46 20.595-46 46s20.595 46 46 46 46-20.595 46-46-20.595-46-46-46zm-43.673-165.346l7.418 136c.347 6.364 5.609 11.346 11.982 11.346h48.546c6.373 0 11.635-4.982 11.982-11.346l7.418-136c.375-6.874-5.098-12.654-11.982-12.654h-63.383c-6.884 0-12.356 5.78-11.981 12.654z"],
+      "exclamation-triangle": [576, 512, [], "f071", "M569.517 440.013C587.975 472.007 564.806 512 527.94 512H48.054c-36.937 0-59.999-40.055-41.577-71.987L246.423 23.985c18.467-32.009 64.72-31.951 83.154 0l239.94 416.028zM288 354c-25.405 0-46 20.595-46 46s20.595 46 46 46 46-20.595 46-46-20.595-46-46-46zm-43.673-165.346l7.418 136c.347 6.364 5.609 11.346 11.982 11.346h48.546c6.373 0 11.635-4.982 11.982-11.346l7.418-136c.375-6.874-5.098-12.654-11.982-12.654h-63.383c-6.884 0-12.356 5.78-11.981 12.654z"],
+      "minus": [448, 512, [], "f068", "M424 318.2c13.3 0 24-10.7 24-24v-76.4c0-13.3-10.7-24-24-24H24c-13.3 0-24 10.7-24 24v76.4c0 13.3 10.7 24 24 24h400z"],
+      "minus-circle": [512, 512, [], "f056", "M256 8C119 8 8 119 8 256s111 248 248 248 248-111 248-248S393 8 256 8zM124 296c-6.6 0-12-5.4-12-12v-56c0-6.6 5.4-12 12-12h264c6.6 0 12 5.4 12 12v56c0 6.6-5.4 12-12 12H124z"],
+      "minus-square": [448, 512, [], "f146", "M400 32H48C21.5 32 0 53.5 0 80v352c0 26.5 21.5 48 48 48h352c26.5 0 48-21.5 48-48V80c0-26.5-21.5-48-48-48zM92 296c-6.6 0-12-5.4-12-12v-56c0-6.6 5.4-12 12-12h264c6.6 0 12 5.4 12 12v56c0 6.6-5.4 12-12 12H92z"],
+      "plus": [448, 512, [], "f067", "M448 294.2v-76.4c0-13.3-10.7-24-24-24H286.2V56c0-13.3-10.7-24-24-24h-76.4c-13.3 0-24 10.7-24 24v137.8H24c-13.3 0-24 10.7-24 24v76.4c0 13.3 10.7 24 24 24h137.8V456c0 13.3 10.7 24 24 24h76.4c13.3 0 24-10.7 24-24V318.2H424c13.3 0 24-10.7 24-24z"],
+      "plus-circle": [512, 512, [], "f055", "M256 8C119 8 8 119 8 256s111 248 248 248 248-111 248-248S393 8 256 8zm144 276c0 6.6-5.4 12-12 12h-92v92c0 6.6-5.4 12-12 12h-56c-6.6 0-12-5.4-12-12v-92h-92c-6.6 0-12-5.4-12-12v-56c0-6.6 5.4-12 12-12h92v-92c0-6.6 5.4-12 12-12h56c6.6 0 12 5.4 12 12v92h92c6.6 0 12 5.4 12 12v56z"],
+      "plus-square": [448, 512, [], "f0fe", "M400 32H48C21.5 32 0 53.5 0 80v352c0 26.5 21.5 48 48 48h352c26.5 0 48-21.5 48-48V80c0-26.5-21.5-48-48-48zm-32 252c0 6.6-5.4 12-12 12h-92v92c0 6.6-5.4 12-12 12h-56c-6.6 0-12-5.4-12-12v-92H92c-6.6 0-12-5.4-12-12v-56c0-6.6 5.4-12 12-12h92v-92c0-6.6 5.4-12 12-12h56c6.6 0 12 5.4 12 12v92h92c6.6 0 12 5.4 12 12v56z"],
+      "question": [384, 512, [], "f128", "M202.021 0C122.202 0 70.503 32.703 29.914 91.026c-7.363 10.58-5.093 25.086 5.178 32.874l43.138 32.709c10.373 7.865 25.132 6.026 33.253-4.148 25.049-31.381 43.63-49.449 82.757-49.449 30.764 0 68.816 19.799 68.816 49.631 0 22.552-18.617 34.134-48.993 51.164-35.423 19.86-82.299 44.576-82.299 106.405V320c0 13.255 10.745 24 24 24h72.471c13.255 0 24-10.745 24-24v-5.773c0-42.86 125.268-44.645 125.268-160.627C377.504 66.256 286.902 0 202.021 0zM192 373.459c-38.196 0-69.271 31.075-69.271 69.271 0 38.195 31.075 69.27 69.271 69.27s69.271-31.075 69.271-69.271-31.075-69.27-69.271-69.27z"],
+      "save": [448, 512, [], "f0c7", "M433.941 129.941l-83.882-83.882A48 48 0 0 0 316.118 32H48C21.49 32 0 53.49 0 80v352c0 26.51 21.49 48 48 48h352c26.51 0 48-21.49 48-48V163.882a48 48 0 0 0-14.059-33.941zM224 416c-35.346 0-64-28.654-64-64 0-35.346 28.654-64 64-64s64 28.654 64 64c0 35.346-28.654 64-64 64zm96-304.52V212c0 6.627-5.373 12-12 12H76c-6.627 0-12-5.373-12-12V108c0-6.627 5.373-12 12-12h228.52c3.183 0 6.235 1.264 8.485 3.515l3.48 3.48A11.996 11.996 0 0 1 320 111.48z"],
+      "search": [512, 512, [], "f002", "M505 442.7L405.3 343c-4.5-4.5-10.6-7-17-7H372c27.6-35.3 44-79.7 44-128C416 93.1 322.9 0 208 0S0 93.1 0 208s93.1 208 208 208c48.3 0 92.7-16.4 128-44v16.3c0 6.4 2.5 12.5 7 17l99.7 99.7c9.4 9.4 24.6 9.4 33.9 0l28.3-28.3c9.4-9.4 9.4-24.6.1-34zM208 336c-70.7 0-128-57.2-128-128 0-70.7 57.2-128 128-128 70.7 0 128 57.2 128 128 0 70.7-57.2 128-128 128z"],
+      "share": [512, 512, [], "f064", "M503.691 189.836L327.687 37.851C312.281 24.546 288 35.347 288 56.015v80.053C127.371 137.907 0 170.1 0 322.326c0 61.441 39.581 122.309 83.333 154.132 13.653 9.931 33.111-2.533 28.077-18.631C66.066 312.814 132.917 274.316 288 272.085V360c0 20.7 24.3 31.453 39.687 18.164l176.004-152c11.071-9.562 11.086-26.753 0-36.328z"],
+      "spinner": [512, 512, [], "f110", "M304 48c0 26.51-21.49 48-48 48s-48-21.49-48-48 21.49-48 48-48 48 21.49 48 48zm-48 368c-26.51 0-48 21.49-48 48s21.49 48 48 48 48-21.49 48-48-21.49-48-48-48zm208-208c-26.51 0-48 21.49-48 48s21.49 48 48 48 48-21.49 48-48-21.49-48-48-48zM96 256c0-26.51-21.49-48-48-48S0 229.49 0 256s21.49 48 48 48 48-21.49 48-48zm12.922 99.078c-26.51 0-48 21.49-48 48s21.49 48 48 48 48-21.49 48-48c0-26.509-21.491-48-48-48zm294.156 0c-26.51 0-48 21.49-48 48s21.49 48 48 48 48-21.49 48-48c0-26.509-21.49-48-48-48zM108.922 60.922c-26.51 0-48 21.49-48 48s21.49 48 48 48 48-21.49 48-48-21.491-48-48-48z"],
+      "square": [448, 512, [], "f0c8", "M400 32H48C21.5 32 0 53.5 0 80v352c0 26.5 21.5 48 48 48h352c26.5 0 48-21.5 48-48V80c0-26.5-21.5-48-48-48z"],
+      "square-full": [512, 512, [], "f45c", "M512 512H0V0h512v512z"],
+      "times": [384, 512, [], "f00d", "M323.1 441l53.9-53.9c9.4-9.4 9.4-24.5 0-33.9L279.8 256l97.2-97.2c9.4-9.4 9.4-24.5 0-33.9L323.1 71c-9.4-9.4-24.5-9.4-33.9 0L192 168.2 94.8 71c-9.4-9.4-24.5-9.4-33.9 0L7 124.9c-9.4 9.4-9.4 24.5 0 33.9l97.2 97.2L7 353.2c-9.4 9.4-9.4 24.5 0 33.9L60.9 441c9.4 9.4 24.5 9.4 33.9 0l97.2-97.2 97.2 97.2c9.3 9.3 24.5 9.3 33.9 0z"],
+      "times-circle": [512, 512, [], "f057", "M256 8C119 8 8 119 8 256s111 248 248 248 248-111 248-248S393 8 256 8zm121.6 313.1c4.7 4.7 4.7 12.3 0 17L338 377.6c-4.7 4.7-12.3 4.7-17 0L256 312l-65.1 65.6c-4.7 4.7-12.3 4.7-17 0L134.4 338c-4.7-4.7-4.7-12.3 0-17l65.6-65-65.6-65.1c-4.7-4.7-4.7-12.3 0-17l39.6-39.6c4.7-4.7 12.3-4.7 17 0l65 65.7 65.1-65.6c4.7-4.7 12.3-4.7 17 0l39.6 39.6c4.7 4.7 4.7 12.3 0 17L312 256l65.6 65.1z"],
+      "wrench": [512, 512, [], "f0ad", "M481.156 200c9.3 0 15.12 10.155 10.325 18.124C466.295 259.992 420.419 288 368 288c-79.222 0-143.501-63.974-143.997-143.079C223.505 65.469 288.548-.001 368.002 0c52.362.001 98.196 27.949 123.4 69.743C496.24 77.766 490.523 88 481.154 88H376l-40 56 40 56h105.156zm-171.649 93.003L109.255 493.255c-24.994 24.993-65.515 24.994-90.51 0-24.993-24.994-24.993-65.516 0-90.51L218.991 202.5c16.16 41.197 49.303 74.335 90.516 90.503zM104 432c0-13.255-10.745-24-24-24s-24 10.745-24 24 10.745 24 24 24 24-10.745 24-24z"]
+    };
+
+    function attachDialogCloseHandlerWithParent(parent, closeHandler) {
+      var container = document.createElement("div");
+      parent.appendChild(container);
+      container.appendChild(createIcon("times"));
+      container.addEventListener('click', function (e) {
+        e.preventDefault();
+        e.stopPropagation();
+        closeHandler();
+      });
+    }
+    /**
+     * @fileoverview Zlib namespace. Zlib ã®ä»•æ§˜ã«æº–æ‹ ã—ãŸåœ§ç¸®ã¯ Zlib.Deflate で実装
+     * されている. これは Inflate との共存を考慮している為.
+     */
+
+
+    const ZLIB_STREAM_RAW_INFLATE_BUFFER_SIZE = 65000;
+    var Zlib = {
+      Huffman: {},
+      Util: {},
+      CRC32: {}
+    };
+    /**
+     * Compression Method
+     * @enum {number}
+     */
+
+    Zlib.CompressionMethod = {
+      DEFLATE: 8,
+      RESERVED: 15
+    };
+    /**
+     * @param {Object=} opt_params options.
+     * @constructor
+     */
+
+    Zlib.Zip = function (opt_params) {
+      opt_params = opt_params || {};
+      /** @type {Array.<{
+       *   buffer: !(Array.<number>|Uint8Array),
+       *   option: Object,
+       *   compressed: boolean,
+       *   encrypted: boolean,
+       *   size: number,
+       *   crc32: number
+       * }>} */
+
+      this.files = [];
+      /** @type {(Array.<number>|Uint8Array)} */
+
+      this.comment = opt_params['comment'];
+      /** @type {(Array.<number>|Uint8Array)} */
+
+      this.password;
+    };
+    /**
+     * @enum {number}
+     */
+
+
+    Zlib.Zip.CompressionMethod = {
+      STORE: 0,
+      DEFLATE: 8
+    };
+    /**
+     * @enum {number}
+     */
+
+    Zlib.Zip.OperatingSystem = {
+      MSDOS: 0,
+      UNIX: 3,
+      MACINTOSH: 7
+    };
+    /**
+     * @enum {number}
+     */
+
+    Zlib.Zip.Flags = {
+      ENCRYPT: 0x0001,
+      DESCRIPTOR: 0x0008,
+      UTF8: 0x0800
+    };
+    /**
+     * @type {Array.<number>}
+     * @const
+     */
+
+    Zlib.Zip.FileHeaderSignature = [0x50, 0x4b, 0x01, 0x02];
+    /**
+     * @type {Array.<number>}
+     * @const
+     */
+
+    Zlib.Zip.LocalFileHeaderSignature = [0x50, 0x4b, 0x03, 0x04];
+    /**
+     * @type {Array.<number>}
+     * @const
+     */
+
+    Zlib.Zip.CentralDirectorySignature = [0x50, 0x4b, 0x05, 0x06];
+    /**
+     * @param {Array.<number>|Uint8Array} input
+     * @param {Object=} opt_params options.
+     */
+
+    Zlib.Zip.prototype.addFile = function (input, opt_params) {
+      opt_params = opt_params || {};
+      /** @type {string} */
+
+      opt_params['filename'];
+      /** @type {boolean} */
+
+      var compressed;
+      /** @type {number} */
+
+      var size = input.length;
+      /** @type {number} */
+
+      var crc32 = 0;
+
+      if (input instanceof Array) {
+        input = new Uint8Array(input);
+      } // default
+
+
+      if (typeof opt_params['compressionMethod'] !== 'number') {
+        opt_params['compressionMethod'] = Zlib.Zip.CompressionMethod.DEFLATE;
+      } // ãã®å ´ã§åœ§ç¸®ã™ã‚‹å ´åˆ
+
+
+      if (opt_params['compress']) {
+        switch (opt_params['compressionMethod']) {
+          case Zlib.Zip.CompressionMethod.STORE:
+            break;
+
+          case Zlib.Zip.CompressionMethod.DEFLATE:
+            crc32 = Zlib.CRC32.calc(input);
+            input = this.deflateWithOption(input, opt_params);
+            compressed = true;
+            break;
+
+          default:
+            throw new Error('unknown compression method:' + opt_params['compressionMethod']);
+        }
+      }
+
+      this.files.push({
+        buffer: input,
+        option: opt_params,
+        compressed: compressed,
+        encrypted: false,
+        size: size,
+        crc32: crc32
+      });
+    };
+    /**
+     * @param {(Array.<number>|Uint8Array)} password
+     */
+
+
+    Zlib.Zip.prototype.setPassword = function (password) {
+      this.password = password;
+    };
+
+    Zlib.Zip.prototype.compress = function () {
+      /** @type {Array.<{
+       *   buffer: !(Array.<number>|Uint8Array),
+       *   option: Object,
+       *   compressed: boolean,
+       *   encrypted: boolean,
+       *   size: number,
+       *   crc32: number
+       * }>} */
+      var files = this.files;
+      /** @type {{
+       *   buffer: !(Array.<number>|Uint8Array),
+       *   option: Object,
+       *   compressed: boolean,
+       *   encrypted: boolean,
+       *   size: number,
+       *   crc32: number
+       * }} */
+
+      var file;
+      /** @type {!(Array.<number>|Uint8Array)} */
+
+      var output;
+      /** @type {number} */
+
+      var op1;
+      /** @type {number} */
+
+      var op2;
+      /** @type {number} */
+
+      var op3;
+      /** @type {number} */
+
+      var localFileSize = 0;
+      /** @type {number} */
+
+      var centralDirectorySize = 0;
+      /** @type {number} */
+
+      var endOfCentralDirectorySize;
+      /** @type {number} */
+
+      var offset;
+      /** @type {number} */
+
+      var needVersion;
+      /** @type {number} */
+
+      var flags;
+      /** @type {Zlib.Zip.CompressionMethod} */
+
+      var compressionMethod;
+      /** @type {Date} */
+
+      var date;
+      /** @type {number} */
+
+      var crc32;
+      /** @type {number} */
+
+      var size;
+      /** @type {number} */
+
+      var plainSize;
+      /** @type {number} */
+
+      var filenameLength;
+      /** @type {number} */
+
+      var extraFieldLength;
+      /** @type {number} */
+
+      var commentLength;
+      /** @type {(Array.<number>|Uint8Array)} */
+
+      var filename;
+      /** @type {(Array.<number>|Uint8Array)} */
+
+      var extraField;
+      /** @type {(Array.<number>|Uint8Array)} */
+
+      var comment;
+      /** @type {(Array.<number>|Uint8Array)} */
+
+      var buffer;
+      /** @type {*} */
+
+      var tmp;
+      /** @type {Array.<number>|Uint32Array|Object} */
+
+      var key;
+      /** @type {number} */
+
+      var i;
+      /** @type {number} */
+
+      var il;
+      /** @type {number} */
+
+      var j;
+      /** @type {number} */
+
+      var jl; // ファイルの圧縮
+
+      for (i = 0, il = files.length; i < il; ++i) {
+        file = files[i];
+        filenameLength = file.option['filename'] ? file.option['filename'].length : 0;
+        extraFieldLength = file.option['extraField'] ? file.option['extraField'].length : 0;
+        commentLength = file.option['comment'] ? file.option['comment'].length : 0; // 圧縮されていなかったら圧縮
+
+        if (!file.compressed) {
+          // 圧縮前に CRC32 の計算をしておく
+          file.crc32 = Zlib.CRC32.calc(file.buffer);
+
+          switch (file.option['compressionMethod']) {
+            case Zlib.Zip.CompressionMethod.STORE:
+              break;
+
+            case Zlib.Zip.CompressionMethod.DEFLATE:
+              file.buffer = this.deflateWithOption(file.buffer, file.option);
+              file.compressed = true;
+              break;
+
+            default:
+              throw new Error('unknown compression method:' + file.option['compressionMethod']);
+          }
+        } // encryption
+
+
+        if (file.option['password'] !== void 0 || this.password !== void 0) {
+          // init encryption
+          key = this.createEncryptionKey(file.option['password'] || this.password); // add header
+
+          buffer = file.buffer;
+          {
+            tmp = new Uint8Array(buffer.length + 12);
+            tmp.set(buffer, 12);
+            buffer = tmp;
+          }
+
+          for (j = 0; j < 12; ++j) {
+            buffer[j] = this.encode(key, i === 11 ? file.crc32 & 0xff : Math.random() * 256 | 0);
+          } // data encryption
+
+
+          for (jl = buffer.length; j < jl; ++j) {
+            buffer[j] = this.encode(key, buffer[j]);
+          }
+
+          file.buffer = buffer;
+        } // 必要バッファサイズの計算
+
+
+        localFileSize += // local file header
+        30 + filenameLength + // file data
+        file.buffer.length;
+        centralDirectorySize += // file header
+        46 + filenameLength + commentLength;
+      } // end of central directory
+
+
+      endOfCentralDirectorySize = 22 + (this.comment ? this.comment.length : 0);
+      output = new Uint8Array(localFileSize + centralDirectorySize + endOfCentralDirectorySize);
+      op1 = 0;
+      op2 = localFileSize;
+      op3 = op2 + centralDirectorySize; // ファイルの圧縮
+
+      for (i = 0, il = files.length; i < il; ++i) {
+        file = files[i];
+        filenameLength = file.option['filename'] ? file.option['filename'].length : 0;
+        extraFieldLength = 0; // TODO
+
+        commentLength = file.option['comment'] ? file.option['comment'].length : 0; //-------------------------------------------------------------------------
+        // local file header & file header
+        //-------------------------------------------------------------------------
+
+        offset = op1; // signature
+        // local file header
+
+        output[op1++] = Zlib.Zip.LocalFileHeaderSignature[0];
+        output[op1++] = Zlib.Zip.LocalFileHeaderSignature[1];
+        output[op1++] = Zlib.Zip.LocalFileHeaderSignature[2];
+        output[op1++] = Zlib.Zip.LocalFileHeaderSignature[3]; // file header
+
+        output[op2++] = Zlib.Zip.FileHeaderSignature[0];
+        output[op2++] = Zlib.Zip.FileHeaderSignature[1];
+        output[op2++] = Zlib.Zip.FileHeaderSignature[2];
+        output[op2++] = Zlib.Zip.FileHeaderSignature[3]; // compressor info
+
+        needVersion = 20;
+        output[op2++] = needVersion & 0xff;
+        output[op2++] =
+        /** @type {Zlib.Zip.OperatingSystem} */
+        file.option['os'] || Zlib.Zip.OperatingSystem.MSDOS; // need version
+
+        output[op1++] = output[op2++] = needVersion & 0xff;
+        output[op1++] = output[op2++] = needVersion >> 8 & 0xff; // general purpose bit flag
+
+        flags = 0;
+
+        if (file.option['password'] || this.password) {
+          flags |= Zlib.Zip.Flags.ENCRYPT;
+        }
+
+        output[op1++] = output[op2++] = flags & 0xff;
+        output[op1++] = output[op2++] = flags >> 8 & 0xff; // compression method
+
+        compressionMethod = file.option['compressionMethod'];
+        output[op1++] = output[op2++] = compressionMethod & 0xff;
+        output[op1++] = output[op2++] = compressionMethod >> 8 & 0xff; // date
+
+        date =
+        /** @type {(Date|undefined)} */
+        file.option['date'] || new Date();
+        output[op1++] = output[op2++] = (date.getMinutes() & 0x7) << 5 | (date.getSeconds() / 2 | 0);
+        output[op1++] = output[op2++] = date.getHours() << 3 | date.getMinutes() >> 3; //
+
+        output[op1++] = output[op2++] = (date.getMonth() + 1 & 0x7) << 5 | date.getDate();
+        output[op1++] = output[op2++] = (date.getFullYear() - 1980 & 0x7f) << 1 | date.getMonth() + 1 >> 3; // CRC-32
+
+        crc32 = file.crc32;
+        output[op1++] = output[op2++] = crc32 & 0xff;
+        output[op1++] = output[op2++] = crc32 >> 8 & 0xff;
+        output[op1++] = output[op2++] = crc32 >> 16 & 0xff;
+        output[op1++] = output[op2++] = crc32 >> 24 & 0xff; // compressed size
+
+        size = file.buffer.length;
+        output[op1++] = output[op2++] = size & 0xff;
+        output[op1++] = output[op2++] = size >> 8 & 0xff;
+        output[op1++] = output[op2++] = size >> 16 & 0xff;
+        output[op1++] = output[op2++] = size >> 24 & 0xff; // uncompressed size
+
+        plainSize = file.size;
+        output[op1++] = output[op2++] = plainSize & 0xff;
+        output[op1++] = output[op2++] = plainSize >> 8 & 0xff;
+        output[op1++] = output[op2++] = plainSize >> 16 & 0xff;
+        output[op1++] = output[op2++] = plainSize >> 24 & 0xff; // filename length
+
+        output[op1++] = output[op2++] = filenameLength & 0xff;
+        output[op1++] = output[op2++] = filenameLength >> 8 & 0xff; // extra field length
+
+        output[op1++] = output[op2++] = extraFieldLength & 0xff;
+        output[op1++] = output[op2++] = extraFieldLength >> 8 & 0xff; // file comment length
+
+        output[op2++] = commentLength & 0xff;
+        output[op2++] = commentLength >> 8 & 0xff; // disk number start
+
+        output[op2++] = 0;
+        output[op2++] = 0; // internal file attributes
+
+        output[op2++] = 0;
+        output[op2++] = 0; // external file attributes
+
+        output[op2++] = 0;
+        output[op2++] = 0;
+        output[op2++] = 0;
+        output[op2++] = 0; // relative offset of local header
+
+        output[op2++] = offset & 0xff;
+        output[op2++] = offset >> 8 & 0xff;
+        output[op2++] = offset >> 16 & 0xff;
+        output[op2++] = offset >> 24 & 0xff; // filename
+
+        filename = file.option['filename'];
+
+        if (filename) {
+          {
+            output.set(filename, op1);
+            output.set(filename, op2);
+            op1 += filenameLength;
+            op2 += filenameLength;
+          }
+        } // extra field
+
+
+        extraField = file.option['extraField'];
+
+        if (extraField) {
+          {
+            output.set(extraField, op1);
+            output.set(extraField, op2);
+            op1 += extraFieldLength;
+            op2 += extraFieldLength;
+          }
+        } // comment
+
+
+        comment = file.option['comment'];
+
+        if (comment) {
+          {
+            output.set(comment, op2);
+            op2 += commentLength;
+          }
+        } //-------------------------------------------------------------------------
+        // file data
+        //-------------------------------------------------------------------------
+
+
+        {
+          output.set(file.buffer, op1);
+          op1 += file.buffer.length;
+        }
+      } //-------------------------------------------------------------------------
+      // end of central directory
+      //-------------------------------------------------------------------------
+      // signature
+
+
+      output[op3++] = Zlib.Zip.CentralDirectorySignature[0];
+      output[op3++] = Zlib.Zip.CentralDirectorySignature[1];
+      output[op3++] = Zlib.Zip.CentralDirectorySignature[2];
+      output[op3++] = Zlib.Zip.CentralDirectorySignature[3]; // number of this disk
+
+      output[op3++] = 0;
+      output[op3++] = 0; // number of the disk with the start of the central directory
+
+      output[op3++] = 0;
+      output[op3++] = 0; // total number of entries in the central directory on this disk
+
+      output[op3++] = il & 0xff;
+      output[op3++] = il >> 8 & 0xff; // total number of entries in the central directory
+
+      output[op3++] = il & 0xff;
+      output[op3++] = il >> 8 & 0xff; // size of the central directory
+
+      output[op3++] = centralDirectorySize & 0xff;
+      output[op3++] = centralDirectorySize >> 8 & 0xff;
+      output[op3++] = centralDirectorySize >> 16 & 0xff;
+      output[op3++] = centralDirectorySize >> 24 & 0xff; // offset of start of central directory with respect to the starting disk number
+
+      output[op3++] = localFileSize & 0xff;
+      output[op3++] = localFileSize >> 8 & 0xff;
+      output[op3++] = localFileSize >> 16 & 0xff;
+      output[op3++] = localFileSize >> 24 & 0xff; // .ZIP file comment length
+
+      commentLength = this.comment ? this.comment.length : 0;
+      output[op3++] = commentLength & 0xff;
+      output[op3++] = commentLength >> 8 & 0xff; // .ZIP file comment
+
+      if (this.comment) {
+        {
+          output.set(this.comment, op3);
+          op3 += commentLength;
+        }
+      }
+
+      return output;
+    };
+    /**
+     * @param {!(Array.<number>|Uint8Array)} input
+     * @param {Object=} opt_params options.
+     * @return {!(Array.<number>|Uint8Array)}
+     */
+
+
+    Zlib.Zip.prototype.deflateWithOption = function (input, opt_params) {
+      /** @type {Zlib.RawDeflate} */
+      var deflator = new Zlib.RawDeflate(input, opt_params['deflateOption']);
+      return deflator.compress();
+    };
+    /**
+     * @param {(Array.<number>|Uint32Array)} key
+     * @return {number}
+     */
+
+
+    Zlib.Zip.prototype.getByte = function (key) {
+      /** @type {number} */
+      var tmp = key[2] & 0xffff | 2;
+      return tmp * (tmp ^ 1) >> 8 & 0xff;
+    };
+    /**
+     * @param {(Array.<number>|Uint32Array|Object)} key
+     * @param {number} n
+     * @return {number}
+     */
+
+
+    Zlib.Zip.prototype.encode = function (key, n) {
+      /** @type {number} */
+      var tmp = this.getByte(key);
+      this.updateKeys(key, n);
+      return tmp ^ n;
+    };
+    /**
+     * @param {(Array.<number>|Uint32Array)} key
+     * @param {number} n
+     */
+
+
+    Zlib.Zip.prototype.updateKeys = function (key, n) {
+      key[0] = Zlib.CRC32.single(key[0], n);
+      key[1] = (((key[1] + (key[0] & 0xff)) * 20173 >>> 0) * 6681 >>> 0) + 1 >>> 0;
+      key[2] = Zlib.CRC32.single(key[2], key[1] >>> 24);
+    };
+    /**
+     * @param {(Array.<number>|Uint8Array)} password
+     * @return {!(Array.<number>|Uint32Array|Object)}
+     */
+
+
+    Zlib.Zip.prototype.createEncryptionKey = function (password) {
+      /** @type {!(Array.<number>|Uint32Array)} */
+      var key = [305419896, 591751049, 878082192];
+      /** @type {number} */
+
+      var i;
+      /** @type {number} */
+
+      var il;
+      {
+        key = new Uint32Array(key);
+      }
+
+      for (i = 0, il = password.length; i < il; ++i) {
+        this.updateKeys(key, password[i] & 0xff);
+      }
+
+      return key;
+    };
+    /**
+     * build huffman table from length list.
+     * @param {!(Array.<number>|Uint8Array)} lengths length list.
+     * @return {!Array} huffman table.
+     */
+
+
+    Zlib.Huffman.buildHuffmanTable = function (lengths) {
+      /** @type {number} length list size. */
+      var listSize = lengths.length;
+      /** @type {number} max code length for table size. */
+
+      var maxCodeLength = 0;
+      /** @type {number} min code length for table size. */
+
+      var minCodeLength = Number.POSITIVE_INFINITY;
+      /** @type {number} table size. */
+
+      var size;
+      /** @type {!(Array|Uint8Array)} huffman code table. */
+
+      var table;
+      /** @type {number} bit length. */
+
+      var bitLength;
+      /** @type {number} huffman code. */
+
+      var code;
+      /**
+       * サイズが 2^maxlength 個のテーブルを埋めるためのスキップ長.
+       * @type {number} skip length for table filling.
+       */
+
+      var skip;
+      /** @type {number} reversed code. */
+
+      var reversed;
+      /** @type {number} reverse temp. */
+
+      var rtemp;
+      /** @type {number} loop counter. */
+
+      var i;
+      /** @type {number} loop limit. */
+
+      var il;
+      /** @type {number} loop counter. */
+
+      var j;
+      /** @type {number} table value. */
+
+      var value; // Math.max は遅いので最長の値は for-loop で取得する
+
+      for (i = 0, il = listSize; i < il; ++i) {
+        if (lengths[i] > maxCodeLength) {
+          maxCodeLength = lengths[i];
+        }
+
+        if (lengths[i] < minCodeLength) {
+          minCodeLength = lengths[i];
+        }
+      }
+
+      size = 1 << maxCodeLength;
+      table = new Uint32Array(size); // ãƒ“ãƒƒãƒˆé•·ã®çŸ­ã„é †ã‹ã‚‰ãƒãƒ•ãƒžãƒ³ç¬¦å·ã‚’å‰²ã‚Šå½“ã¦ã‚‹
+
+      for (bitLength = 1, code = 0, skip = 2; bitLength <= maxCodeLength;) {
+        for (i = 0; i < listSize; ++i) {
+          if (lengths[i] === bitLength) {
+            // ビットオーダーが逆になるためビット長分並びを反転する
+            for (reversed = 0, rtemp = code, j = 0; j < bitLength; ++j) {
+              reversed = reversed << 1 | rtemp & 1;
+              rtemp >>= 1;
+            } // 最大ビット長をもとにテーブルを作るため、
+            // 最大ビット長以外では 0 / 1 どちらでも良い箇所ができる
+            // ãã®ã©ã¡ã‚‰ã§ã‚‚è‰¯ã„å ´æ‰€ã¯åŒã˜å€¤ã§åŸ‹ã‚ã‚‹ã“ã¨ã§
+            // 本来のビット長以上のビット数取得しても問題が起こらないようにする
+
+
+            value = bitLength << 16 | i;
+
+            for (j = reversed; j < size; j += skip) {
+              table[j] = value;
+            }
+
+            ++code;
+          }
+        } // 次のビット長へ
+
+
+        ++bitLength;
+        code <<= 1;
+        skip <<= 1;
+      }
+
+      return [table, maxCodeLength, minCodeLength];
+    }; //-----------------------------------------------------------------------------
+
+    /** @define {number} buffer block size. */
+
+
+    var ZLIB_RAW_INFLATE_BUFFER_SIZE = 0x8000; // [ 0x8000 >= ZLIB_BUFFER_BLOCK_SIZE ]
+    //-----------------------------------------------------------------------------
+
+    var buildHuffmanTable = Zlib.Huffman.buildHuffmanTable;
+    /**
+     * @constructor
+     * @param {!(Uint8Array|Array.<number>)} input input buffer.
+     * @param {Object} opt_params option parameter.
+     *
+     * opt_params は以下のプロパティを指定する事ができます。
+     *   - index: input buffer の deflate コンテナの開始位置.
+     *   - blockSize: バッファのブロックサイズ.
+     *   - bufferType: Zlib.RawInflate.BufferType の値によってバッファの管理方法を指定する.
+     *   - resize: ç¢ºä¿ã—ãŸãƒãƒƒãƒ•ã‚¡ãŒå®Ÿéš›ã®å¤§ãã•ã‚ˆã‚Šå¤§ãã‹ã£ãŸå ´åˆã«åˆ‡ã‚Šè©°ã‚ã‚‹.
+     */
+
+    Zlib.RawInflate = function (input, opt_params) {
+      /** @type {!(Array.<number>|Uint8Array)} inflated buffer */
+      this.buffer;
+      /** @type {!Array.<(Array.<number>|Uint8Array)>} */
+
+      this.blocks = [];
+      /** @type {number} block size. */
+
+      this.bufferSize = ZLIB_RAW_INFLATE_BUFFER_SIZE;
+      /** @type {!number} total output buffer pointer. */
+
+      this.totalpos = 0;
+      /** @type {!number} input buffer pointer. */
+
+      this.ip = 0;
+      /** @type {!number} bit stream reader buffer. */
+
+      this.bitsbuf = 0;
+      /** @type {!number} bit stream reader buffer size. */
+
+      this.bitsbuflen = 0;
+      /** @type {!(Array.<number>|Uint8Array)} input buffer. */
+
+      this.input = new Uint8Array(input);
+      /** @type {!(Uint8Array|Array.<number>)} output buffer. */
+
+      this.output;
+      /** @type {!number} output buffer pointer. */
+
+      this.op;
+      /** @type {boolean} is final block flag. */
+
+      this.bfinal = false;
+      /** @type {Zlib.RawInflate.BufferType} buffer management. */
+
+      this.bufferType = Zlib.RawInflate.BufferType.ADAPTIVE;
+      /** @type {boolean} resize flag for memory size optimization. */
+
+      this.resize = false; // option parameters
+
+      if (opt_params || !(opt_params = {})) {
+        if (opt_params['index']) {
+          this.ip = opt_params['index'];
+        }
+
+        if (opt_params['bufferSize']) {
+          this.bufferSize = opt_params['bufferSize'];
+        }
+
+        if (opt_params['bufferType']) {
+          this.bufferType = opt_params['bufferType'];
+        }
+
+        if (opt_params['resize']) {
+          this.resize = opt_params['resize'];
+        }
+      } // initialize
+
+
+      switch (this.bufferType) {
+        case Zlib.RawInflate.BufferType.BLOCK:
+          this.op = Zlib.RawInflate.MaxBackwardLength;
+          this.output = new Uint8Array(Zlib.RawInflate.MaxBackwardLength + this.bufferSize + Zlib.RawInflate.MaxCopyLength);
+          break;
+
+        case Zlib.RawInflate.BufferType.ADAPTIVE:
+          this.op = 0;
+          this.output = new Uint8Array(this.bufferSize);
+          break;
+
+        default:
+          throw new Error('invalid inflate mode');
+      }
+    };
+    /**
+     * @enum {number}
+     */
+
+
+    Zlib.RawInflate.BufferType = {
+      BLOCK: 0,
+      ADAPTIVE: 1
+    };
+    /**
+     * decompress.
+     * @return {!(Uint8Array|Array.<number>)} inflated buffer.
+     */
+
+    Zlib.RawInflate.prototype.decompress = function () {
+      while (!this.bfinal) {
+        this.parseBlock();
+      }
+
+      switch (this.bufferType) {
+        case Zlib.RawInflate.BufferType.BLOCK:
+          return this.concatBufferBlock();
+
+        case Zlib.RawInflate.BufferType.ADAPTIVE:
+          return this.concatBufferDynamic();
+
+        default:
+          throw new Error('invalid inflate mode');
+      }
+    };
+    /**
+     * @const
+     * @type {number} max backward length for LZ77.
+     */
+
+
+    Zlib.RawInflate.MaxBackwardLength = 32768;
+    /**
+     * @const
+     * @type {number} max copy length for LZ77.
+     */
+
+    Zlib.RawInflate.MaxCopyLength = 258;
+    /**
+     * huffman order
+     * @const
+     * @type {!(Array.<number>|Uint8Array)}
+     */
+
+    Zlib.RawInflate.Order = function (table) {
+      return new Uint16Array(table);
+    }([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]);
+    /**
+     * huffman length code table.
+     * @const
+     * @type {!(Array.<number>|Uint16Array)}
+     */
+
+
+    Zlib.RawInflate.LengthCodeTable = function (table) {
+      return new Uint16Array(table);
+    }([0x0003, 0x0004, 0x0005, 0x0006, 0x0007, 0x0008, 0x0009, 0x000a, 0x000b, 0x000d, 0x000f, 0x0011, 0x0013, 0x0017, 0x001b, 0x001f, 0x0023, 0x002b, 0x0033, 0x003b, 0x0043, 0x0053, 0x0063, 0x0073, 0x0083, 0x00a3, 0x00c3, 0x00e3, 0x0102, 0x0102, 0x0102]);
+    /**
+     * huffman length extra-bits table.
+     * @const
+     * @type {!(Array.<number>|Uint8Array)}
+     */
+
+
+    Zlib.RawInflate.LengthExtraTable = function (table) {
+      return new Uint8Array(table);
+    }([0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0, 0, 0]);
+    /**
+     * huffman dist code table.
+     * @const
+     * @type {!(Array.<number>|Uint16Array)}
+     */
+
+
+    Zlib.RawInflate.DistCodeTable = function (table) {
+      return new Uint16Array(table);
+    }([0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0007, 0x0009, 0x000d, 0x0011, 0x0019, 0x0021, 0x0031, 0x0041, 0x0061, 0x0081, 0x00c1, 0x0101, 0x0181, 0x0201, 0x0301, 0x0401, 0x0601, 0x0801, 0x0c01, 0x1001, 0x1801, 0x2001, 0x3001, 0x4001, 0x6001]);
+    /**
+     * huffman dist extra-bits table.
+     * @const
+     * @type {!(Array.<number>|Uint8Array)}
+     */
+
+
+    Zlib.RawInflate.DistExtraTable = function (table) {
+      return new Uint8Array(table);
+    }([0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13]);
+    /**
+     * fixed huffman length code table
+     * @const
+     * @type {!Array}
+     */
+
+
+    Zlib.RawInflate.FixedLiteralLengthTable = function (table) {
+      return table;
+    }(function () {
+      var lengths = new Uint8Array(288);
+      var i, il;
+
+      for (i = 0, il = lengths.length; i < il; ++i) {
+        lengths[i] = i <= 143 ? 8 : i <= 255 ? 9 : i <= 279 ? 7 : 8;
+      }
+
+      return buildHuffmanTable(lengths);
+    }());
+    /**
+     * fixed huffman distance code table
+     * @const
+     * @type {!Array}
+     */
+
+
+    Zlib.RawInflate.FixedDistanceTable = function (table) {
+      return table;
+    }(function () {
+      var lengths = new Uint8Array(30);
+      var i, il;
+
+      for (i = 0, il = lengths.length; i < il; ++i) {
+        lengths[i] = 5;
+      }
+
+      return buildHuffmanTable(lengths);
+    }());
+    /**
+     * parse deflated block.
+     */
+
+
+    Zlib.RawInflate.prototype.parseBlock = function () {
+      /** @type {number} header */
+      var hdr = this.readBits(3); // BFINAL
+
+      if (hdr & 0x1) {
+        this.bfinal = true;
+      } // BTYPE
+
+
+      hdr >>>= 1;
+
+      switch (hdr) {
+        // uncompressed
+        case 0:
+          this.parseUncompressedBlock();
+          break;
+        // fixed huffman
+
+        case 1:
+          this.parseFixedHuffmanBlock();
+          break;
+        // dynamic huffman
+
+        case 2:
+          this.parseDynamicHuffmanBlock();
+          break;
+        // reserved or other
+
+        default:
+          throw new Error('unknown BTYPE: ' + hdr);
+      }
+    };
+    /**
+     * read inflate bits
+     * @param {number} length bits length.
+     * @return {number} read bits.
+     */
+
+
+    Zlib.RawInflate.prototype.readBits = function (length) {
+      var bitsbuf = this.bitsbuf;
+      var bitsbuflen = this.bitsbuflen;
+      var input = this.input;
+      var ip = this.ip;
+      /** @type {number} */
+
+      var inputLength = input.length;
+      /** @type {number} input and output byte. */
+
+      var octet; // input byte
+
+      if (ip + (length - bitsbuflen + 7 >> 3) >= inputLength) {
+        throw new Error('input buffer is broken');
+      } // not enough buffer
+
+
+      while (bitsbuflen < length) {
+        bitsbuf |= input[ip++] << bitsbuflen;
+        bitsbuflen += 8;
+      } // output byte
+
+
+      octet = bitsbuf & (1 << length) - 1;
+      bitsbuf >>>= length;
+      bitsbuflen -= length;
+      this.bitsbuf = bitsbuf;
+      this.bitsbuflen = bitsbuflen;
+      this.ip = ip;
+      return octet;
+    };
+    /**
+     * read huffman code using table
+     * @param {!(Array.<number>|Uint8Array|Uint16Array)} table huffman code table.
+     * @return {number} huffman code.
+     */
+
+
+    Zlib.RawInflate.prototype.readCodeByTable = function (table) {
+      var bitsbuf = this.bitsbuf;
+      var bitsbuflen = this.bitsbuflen;
+      var input = this.input;
+      var ip = this.ip;
+      /** @type {number} */
+
+      var inputLength = input.length;
+      /** @type {!(Array.<number>|Uint8Array)} huffman code table */
+
+      var codeTable = table[0];
+      /** @type {number} */
+
+      var maxCodeLength = table[1];
+      /** @type {number} code length & code (16bit, 16bit) */
+
+      var codeWithLength;
+      /** @type {number} code bits length */
+
+      var codeLength; // not enough buffer
+
+      while (bitsbuflen < maxCodeLength) {
+        if (ip >= inputLength) {
+          break;
+        }
+
+        bitsbuf |= input[ip++] << bitsbuflen;
+        bitsbuflen += 8;
+      } // read max length
+
+
+      codeWithLength = codeTable[bitsbuf & (1 << maxCodeLength) - 1];
+      codeLength = codeWithLength >>> 16;
+
+      if (codeLength > bitsbuflen) {
+        throw new Error('invalid code length: ' + codeLength);
+      }
+
+      this.bitsbuf = bitsbuf >> codeLength;
+      this.bitsbuflen = bitsbuflen - codeLength;
+      this.ip = ip;
+      return codeWithLength & 0xffff;
+    };
+    /**
+     * parse uncompressed block.
+     */
+
+
+    Zlib.RawInflate.prototype.parseUncompressedBlock = function () {
+      var input = this.input;
+      var ip = this.ip;
+      var output = this.output;
+      var op = this.op;
+      /** @type {number} */
+
+      var inputLength = input.length;
+      /** @type {number} block length */
+
+      var len;
+      /** @type {number} number for check block length */
+
+      var nlen;
+      /** @type {number} output buffer length */
+
+      var olength = output.length;
+      /** @type {number} copy counter */
+
+      var preCopy; // skip buffered header bits
+
+      this.bitsbuf = 0;
+      this.bitsbuflen = 0; // len
+
+      if (ip + 1 >= inputLength) {
+        throw new Error('invalid uncompressed block header: LEN');
+      }
+
+      len = input[ip++] | input[ip++] << 8; // nlen
+
+      if (ip + 1 >= inputLength) {
+        throw new Error('invalid uncompressed block header: NLEN');
+      }
+
+      nlen = input[ip++] | input[ip++] << 8; // check len & nlen
+
+      if (len === ~nlen) {
+        throw new Error('invalid uncompressed block header: length verify');
+      } // check size
+
+
+      if (ip + len > input.length) {
+        throw new Error('input buffer is broken');
+      } // expand buffer
+
+
+      switch (this.bufferType) {
+        case Zlib.RawInflate.BufferType.BLOCK:
+          // pre copy
+          while (op + len > output.length) {
+            preCopy = olength - op;
+            len -= preCopy;
+            {
+              output.set(input.subarray(ip, ip + preCopy), op);
+              op += preCopy;
+              ip += preCopy;
+            }
+            this.op = op;
+            output = this.expandBufferBlock();
+            op = this.op;
+          }
+
+          break;
+
+        case Zlib.RawInflate.BufferType.ADAPTIVE:
+          while (op + len > output.length) {
+            output = this.expandBufferAdaptive({
+              fixRatio: 2
+            });
+          }
+
+          break;
+
+        default:
+          throw new Error('invalid inflate mode');
+      } // copy
+
+
+      {
+        output.set(input.subarray(ip, ip + len), op);
+        op += len;
+        ip += len;
+      }
+      this.ip = ip;
+      this.op = op;
+      this.output = output;
+    };
+    /**
+     * parse fixed huffman block.
+     */
+
+
+    Zlib.RawInflate.prototype.parseFixedHuffmanBlock = function () {
+      switch (this.bufferType) {
+        case Zlib.RawInflate.BufferType.ADAPTIVE:
+          this.decodeHuffmanAdaptive(Zlib.RawInflate.FixedLiteralLengthTable, Zlib.RawInflate.FixedDistanceTable);
+          break;
+
+        case Zlib.RawInflate.BufferType.BLOCK:
+          this.decodeHuffmanBlock(Zlib.RawInflate.FixedLiteralLengthTable, Zlib.RawInflate.FixedDistanceTable);
+          break;
+
+        default:
+          throw new Error('invalid inflate mode');
+      }
+    };
+    /**
+     * parse dynamic huffman block.
+     */
+
+
+    Zlib.RawInflate.prototype.parseDynamicHuffmanBlock = function () {
+      /** @type {number} number of literal and length codes. */
+      var hlit = this.readBits(5) + 257;
+      /** @type {number} number of distance codes. */
+
+      var hdist = this.readBits(5) + 1;
+      /** @type {number} number of code lengths. */
+
+      var hclen = this.readBits(4) + 4;
+      /** @type {!(Uint8Array|Array.<number>)} code lengths. */
+
+      var codeLengths = new Uint8Array(Zlib.RawInflate.Order.length);
+      /** @type {!Array} code lengths table. */
+
+      var codeLengthsTable;
+      /** @type {!(Uint8Array|Array.<number>)} literal and length code table. */
+
+      var litlenTable;
+      /** @type {!(Uint8Array|Array.<number>)} distance code table. */
+
+      var distTable;
+      /** @type {!(Uint8Array|Array.<number>)} code length table. */
+
+      var lengthTable;
+      /** @type {number} */
+
+      var code;
+      /** @type {number} */
+
+      var prev;
+      /** @type {number} */
+
+      var repeat;
+      /** @type {number} loop counter. */
+
+      var i;
+      /** @type {number} loop limit. */
+
+      var il; // decode code lengths
+
+      for (i = 0; i < hclen; ++i) {
+        codeLengths[Zlib.RawInflate.Order[i]] = this.readBits(3);
+      } // decode length table
+
+
+      codeLengthsTable = buildHuffmanTable(codeLengths);
+      lengthTable = new Uint8Array(hlit + hdist);
+
+      for (i = 0, il = hlit + hdist; i < il;) {
+        code = this.readCodeByTable(codeLengthsTable);
+
+        switch (code) {
+          case 16:
+            repeat = 3 + this.readBits(2);
+
+            while (repeat--) {
+              lengthTable[i++] = prev;
+            }
+
+            break;
+
+          case 17:
+            repeat = 3 + this.readBits(3);
+
+            while (repeat--) {
+              lengthTable[i++] = 0;
+            }
+
+            prev = 0;
+            break;
+
+          case 18:
+            repeat = 11 + this.readBits(7);
+
+            while (repeat--) {
+              lengthTable[i++] = 0;
+            }
+
+            prev = 0;
+            break;
+
+          default:
+            lengthTable[i++] = code;
+            prev = code;
+            break;
+        }
+      }
+
+      litlenTable = buildHuffmanTable(lengthTable.subarray(0, hlit));
+      distTable = buildHuffmanTable(lengthTable.subarray(hlit));
+
+      switch (this.bufferType) {
+        case Zlib.RawInflate.BufferType.ADAPTIVE:
+          this.decodeHuffmanAdaptive(litlenTable, distTable);
+          break;
+
+        case Zlib.RawInflate.BufferType.BLOCK:
+          this.decodeHuffmanBlock(litlenTable, distTable);
+          break;
+
+        default:
+          throw new Error('invalid inflate mode');
+      }
+    };
+    /**
+     * decode huffman code
+     * @param {!(Array.<number>|Uint16Array)} litlen literal and length code table.
+     * @param {!(Array.<number>|Uint8Array)} dist distination code table.
+     */
+
+
+    Zlib.RawInflate.prototype.decodeHuffmanBlock = function (litlen, dist) {
+      var output = this.output;
+      var op = this.op;
+      this.currentLitlenTable = litlen;
+      /** @type {number} output position limit. */
+
+      var olength = output.length - Zlib.RawInflate.MaxCopyLength;
+      /** @type {number} huffman code. */
+
+      var code;
+      /** @type {number} table index. */
+
+      var ti;
+      /** @type {number} huffman code distination. */
+
+      var codeDist;
+      /** @type {number} huffman code length. */
+
+      var codeLength;
+      var lengthCodeTable = Zlib.RawInflate.LengthCodeTable;
+      var lengthExtraTable = Zlib.RawInflate.LengthExtraTable;
+      var distCodeTable = Zlib.RawInflate.DistCodeTable;
+      var distExtraTable = Zlib.RawInflate.DistExtraTable;
+
+      while ((code = this.readCodeByTable(litlen)) !== 256) {
+        // literal
+        if (code < 256) {
+          if (op >= olength) {
+            this.op = op;
+            output = this.expandBufferBlock();
+            op = this.op;
+          }
+
+          output[op++] = code;
+          continue;
+        } // length code
+
+
+        ti = code - 257;
+        codeLength = lengthCodeTable[ti];
+
+        if (lengthExtraTable[ti] > 0) {
+          codeLength += this.readBits(lengthExtraTable[ti]);
+        } // dist code
+
+
+        code = this.readCodeByTable(dist);
+        codeDist = distCodeTable[code];
+
+        if (distExtraTable[code] > 0) {
+          codeDist += this.readBits(distExtraTable[code]);
+        } // lz77 decode
+
+
+        if (op >= olength) {
+          this.op = op;
+          output = this.expandBufferBlock();
+          op = this.op;
+        }
+
+        while (codeLength--) {
+          output[op] = output[op++ - codeDist];
+        }
+      }
+
+      while (this.bitsbuflen >= 8) {
+        this.bitsbuflen -= 8;
+        this.ip--;
+      }
+
+      this.op = op;
+    };
+    /**
+     * decode huffman code (adaptive)
+     * @param {!(Array.<number>|Uint16Array)} litlen literal and length code table.
+     * @param {!(Array.<number>|Uint8Array)} dist distination code table.
+     */
+
+
+    Zlib.RawInflate.prototype.decodeHuffmanAdaptive = function (litlen, dist) {
+      var output = this.output;
+      var op = this.op;
+      this.currentLitlenTable = litlen;
+      /** @type {number} output position limit. */
+
+      var olength = output.length;
+      /** @type {number} huffman code. */
+
+      var code;
+      /** @type {number} table index. */
+
+      var ti;
+      /** @type {number} huffman code distination. */
+
+      var codeDist;
+      /** @type {number} huffman code length. */
+
+      var codeLength;
+      var lengthCodeTable = Zlib.RawInflate.LengthCodeTable;
+      var lengthExtraTable = Zlib.RawInflate.LengthExtraTable;
+      var distCodeTable = Zlib.RawInflate.DistCodeTable;
+      var distExtraTable = Zlib.RawInflate.DistExtraTable;
+
+      while ((code = this.readCodeByTable(litlen)) !== 256) {
+        // literal
+        if (code < 256) {
+          if (op >= olength) {
+            output = this.expandBufferAdaptive();
+            olength = output.length;
+          }
+
+          output[op++] = code;
+          continue;
+        } // length code
+
+
+        ti = code - 257;
+        codeLength = lengthCodeTable[ti];
+
+        if (lengthExtraTable[ti] > 0) {
+          codeLength += this.readBits(lengthExtraTable[ti]);
+        } // dist code
+
+
+        code = this.readCodeByTable(dist);
+        codeDist = distCodeTable[code];
+
+        if (distExtraTable[code] > 0) {
+          codeDist += this.readBits(distExtraTable[code]);
+        } // lz77 decode
+
+
+        if (op + codeLength > olength) {
+          output = this.expandBufferAdaptive();
+          olength = output.length;
+        }
+
+        while (codeLength--) {
+          output[op] = output[op++ - codeDist];
+        }
+      }
+
+      while (this.bitsbuflen >= 8) {
+        this.bitsbuflen -= 8;
+        this.ip--;
+      }
+
+      this.op = op;
+    };
+    /**
+     * expand output buffer.
+     * @param {Object=} opt_param option parameters.
+     * @return {!(Array.<number>|Uint8Array)} output buffer.
+     */
+
+
+    Zlib.RawInflate.prototype.expandBufferBlock = function (opt_param) {
+      /** @type {!(Array.<number>|Uint8Array)} store buffer. */
+      var buffer = new Uint8Array(this.op - Zlib.RawInflate.MaxBackwardLength);
+      /** @type {number} backward base point */
+
+      var backward = this.op - Zlib.RawInflate.MaxBackwardLength;
+      var output = this.output; // copy to output buffer
+
+      {
+        buffer.set(output.subarray(Zlib.RawInflate.MaxBackwardLength, buffer.length));
+      }
+      this.blocks.push(buffer);
+      this.totalpos += buffer.length; // copy to backward buffer
+
+      {
+        output.set(output.subarray(backward, backward + Zlib.RawInflate.MaxBackwardLength));
+      }
+      this.op = Zlib.RawInflate.MaxBackwardLength;
+      return output;
+    };
+    /**
+     * expand output buffer. (adaptive)
+     * @param {Object=} opt_param option parameters.
+     * @return {!(Array.<number>|Uint8Array)} output buffer pointer.
+     */
+
+
+    Zlib.RawInflate.prototype.expandBufferAdaptive = function (opt_param) {
+      /** @type {!(Array.<number>|Uint8Array)} store buffer. */
+      var buffer;
+      /** @type {number} expantion ratio. */
+
+      var ratio = this.input.length / this.ip + 1 | 0;
+      /** @type {number} maximum number of huffman code. */
+
+      var maxHuffCode;
+      /** @type {number} new output buffer size. */
+
+      var newSize;
+      /** @type {number} max inflate size. */
+
+      var maxInflateSize;
+      var input = this.input;
+      var output = this.output;
+
+      if (opt_param) {
+        if (typeof opt_param.fixRatio === 'number') {
+          ratio = opt_param.fixRatio;
+        }
+
+        if (typeof opt_param.addRatio === 'number') {
+          ratio += opt_param.addRatio;
+        }
+      } // calculate new buffer size
+
+
+      if (ratio < 2) {
+        maxHuffCode = (input.length - this.ip) / this.currentLitlenTable[2];
+        maxInflateSize = maxHuffCode / 2 * 258 | 0;
+        newSize = maxInflateSize < output.length ? output.length + maxInflateSize : output.length << 1;
+      } else {
+        newSize = output.length * ratio;
+      } // buffer expantion
+
+
+      {
+        buffer = new Uint8Array(newSize);
+        buffer.set(output);
+      }
+      this.output = buffer;
+      return this.output;
+    };
+    /**
+     * concat output buffer.
+     * @return {!(Array.<number>|Uint8Array)} output buffer.
+     */
+
+
+    Zlib.RawInflate.prototype.concatBufferBlock = function () {
+      /** @type {number} buffer pointer. */
+      var pos = 0;
+      /** @type {number} buffer pointer. */
+
+      var limit = this.totalpos + (this.op - Zlib.RawInflate.MaxBackwardLength);
+      /** @type {!(Array.<number>|Uint8Array)} output block array. */
+
+      var output = this.output;
+      /** @type {!Array} blocks array. */
+
+      var blocks = this.blocks;
+      /** @type {!(Array.<number>|Uint8Array)} output block array. */
+
+      var block;
+      /** @type {!(Array.<number>|Uint8Array)} output buffer. */
+
+      var buffer = new Uint8Array(limit);
+      /** @type {number} loop counter. */
+
+      var i;
+      /** @type {number} loop limiter. */
+
+      var il;
+      /** @type {number} loop counter. */
+
+      var j;
+      /** @type {number} loop limiter. */
+
+      var jl; // single buffer
+
+      if (blocks.length === 0) {
+        return this.output.subarray(Zlib.RawInflate.MaxBackwardLength, this.op);
+      } // copy to buffer
+
+
+      for (i = 0, il = blocks.length; i < il; ++i) {
+        block = blocks[i];
+
+        for (j = 0, jl = block.length; j < jl; ++j) {
+          buffer[pos++] = block[j];
+        }
+      } // current buffer
+
+
+      for (i = Zlib.RawInflate.MaxBackwardLength, il = this.op; i < il; ++i) {
+        buffer[pos++] = output[i];
+      }
+
+      this.blocks = [];
+      this.buffer = buffer;
+      return this.buffer;
+    };
+    /**
+     * concat output buffer. (dynamic)
+     * @return {!(Array.<number>|Uint8Array)} output buffer.
+     */
+
+
+    Zlib.RawInflate.prototype.concatBufferDynamic = function () {
+      /** @type {Array.<number>|Uint8Array} output buffer. */
+      var buffer;
+      var op = this.op;
+      {
+        if (this.resize) {
+          buffer = new Uint8Array(op);
+          buffer.set(this.output.subarray(0, op));
+        } else {
+          buffer = this.output.subarray(0, op);
+        }
+      }
+      this.buffer = buffer;
+      return this.buffer;
+    };
+
+    var buildHuffmanTable = Zlib.Huffman.buildHuffmanTable;
+    /**
+     * @param {!(Uint8Array|Array.<number>)} input input buffer.
+     * @param {number} ip input buffer pointer.
+     * @param {number=} opt_buffersize buffer block size.
+     * @constructor
+     */
+
+    Zlib.RawInflateStream = function (input, ip, opt_buffersize) {
+      /** @type {!Array.<(Array|Uint8Array)>} */
+      this.blocks = [];
+      /** @type {number} block size. */
+
+      this.bufferSize = opt_buffersize ? opt_buffersize : ZLIB_STREAM_RAW_INFLATE_BUFFER_SIZE;
+      /** @type {!number} total output buffer pointer. */
+
+      this.totalpos = 0;
+      /** @type {!number} input buffer pointer. */
+
+      this.ip = ip === void 0 ? 0 : ip;
+      /** @type {!number} bit stream reader buffer. */
+
+      this.bitsbuf = 0;
+      /** @type {!number} bit stream reader buffer size. */
+
+      this.bitsbuflen = 0;
+      /** @type {!(Array|Uint8Array)} input buffer. */
+
+      this.input = new Uint8Array(input);
+      /** @type {!(Uint8Array|Array)} output buffer. */
+
+      this.output = new Uint8Array(this.bufferSize);
+      /** @type {!number} output buffer pointer. */
+
+      this.op = 0;
+      /** @type {boolean} is final block flag. */
+
+      this.bfinal = false;
+      /** @type {number} uncompressed block length. */
+
+      this.blockLength;
+      /** @type {boolean} resize flag for memory size optimization. */
+
+      this.resize = false;
+      /** @type {Array} */
+
+      this.litlenTable;
+      /** @type {Array} */
+
+      this.distTable;
+      /** @type {number} */
+
+      this.sp = 0; // stream pointer
+
+      /** @type {Zlib.RawInflateStream.Status} */
+
+      this.status = Zlib.RawInflateStream.Status.INITIALIZED; //
+      // backup
+      //
+
+      /** @type {!number} */
+
+      this.ip_;
+      /** @type {!number} */
+
+      this.bitsbuflen_;
+      /** @type {!number} */
+
+      this.bitsbuf_;
+    };
+    /**
+     * @enum {number}
+     */
+
+
+    Zlib.RawInflateStream.BlockType = {
+      UNCOMPRESSED: 0,
+      FIXED: 1,
+      DYNAMIC: 2
+    };
+    /**
+     * @enum {number}
+     */
+
+    Zlib.RawInflateStream.Status = {
+      INITIALIZED: 0,
+      BLOCK_HEADER_START: 1,
+      BLOCK_HEADER_END: 2,
+      BLOCK_BODY_START: 3,
+      BLOCK_BODY_END: 4,
+      DECODE_BLOCK_START: 5,
+      DECODE_BLOCK_END: 6
+    };
+    /**
+     * decompress.
+     * @return {!(Uint8Array|Array)} inflated buffer.
+     */
+
+    Zlib.RawInflateStream.prototype.decompress = function (newInput, ip) {
+      /** @type {boolean} */
+      var stop = false;
+
+      if (newInput !== void 0) {
+        this.input = newInput;
+      }
+
+      if (ip !== void 0) {
+        this.ip = ip;
+      } // decompress
+
+
+      while (!stop) {
+        switch (this.status) {
+          // block header
+          case Zlib.RawInflateStream.Status.INITIALIZED:
+          case Zlib.RawInflateStream.Status.BLOCK_HEADER_START:
+            if (this.readBlockHeader() < 0) {
+              stop = true;
+            }
+
+            break;
+          // block body
+
+          case Zlib.RawInflateStream.Status.BLOCK_HEADER_END:
+          /* FALLTHROUGH */
+
+          case Zlib.RawInflateStream.Status.BLOCK_BODY_START:
+            switch (this.currentBlockType) {
+              case Zlib.RawInflateStream.BlockType.UNCOMPRESSED:
+                if (this.readUncompressedBlockHeader() < 0) {
+                  stop = true;
+                }
+
+                break;
+
+              case Zlib.RawInflateStream.BlockType.FIXED:
+                if (this.parseFixedHuffmanBlock() < 0) {
+                  stop = true;
+                }
+
+                break;
+
+              case Zlib.RawInflateStream.BlockType.DYNAMIC:
+                if (this.parseDynamicHuffmanBlock() < 0) {
+                  stop = true;
+                }
+
+                break;
+            }
+
+            break;
+          // decode data
+
+          case Zlib.RawInflateStream.Status.BLOCK_BODY_END:
+          case Zlib.RawInflateStream.Status.DECODE_BLOCK_START:
+            switch (this.currentBlockType) {
+              case Zlib.RawInflateStream.BlockType.UNCOMPRESSED:
+                if (this.parseUncompressedBlock() < 0) {
+                  stop = true;
+                }
+
+                break;
+
+              case Zlib.RawInflateStream.BlockType.FIXED:
+              /* FALLTHROUGH */
+
+              case Zlib.RawInflateStream.BlockType.DYNAMIC:
+                if (this.decodeHuffman() < 0) {
+                  stop = true;
+                }
+
+                break;
+            }
+
+            break;
+
+          case Zlib.RawInflateStream.Status.DECODE_BLOCK_END:
+            if (this.bfinal) {
+              stop = true;
+            } else {
+              this.status = Zlib.RawInflateStream.Status.INITIALIZED;
+            }
+
+            break;
+        }
+      }
+
+      return this.concatBuffer();
+    };
+    /**
+     * @const
+     * @type {number} max backward length for LZ77.
+     */
+
+
+    Zlib.RawInflateStream.MaxBackwardLength = 32768;
+    /**
+     * @const
+     * @type {number} max copy length for LZ77.
+     */
+
+    Zlib.RawInflateStream.MaxCopyLength = 258;
+    /**
+     * huffman order
+     * @const
+     * @type {!(Array.<number>|Uint8Array)}
+     */
+
+    Zlib.RawInflateStream.Order = function (table) {
+      return new Uint16Array(table);
+    }([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]);
+    /**
+     * huffman length code table.
+     * @const
+     * @type {!(Array.<number>|Uint16Array)}
+     */
+
+
+    Zlib.RawInflateStream.LengthCodeTable = function (table) {
+      return new Uint16Array(table);
+    }([0x0003, 0x0004, 0x0005, 0x0006, 0x0007, 0x0008, 0x0009, 0x000a, 0x000b, 0x000d, 0x000f, 0x0011, 0x0013, 0x0017, 0x001b, 0x001f, 0x0023, 0x002b, 0x0033, 0x003b, 0x0043, 0x0053, 0x0063, 0x0073, 0x0083, 0x00a3, 0x00c3, 0x00e3, 0x0102, 0x0102, 0x0102]);
+    /**
+     * huffman length extra-bits table.
+     * @const
+     * @type {!(Array.<number>|Uint8Array)}
+     */
+
+
+    Zlib.RawInflateStream.LengthExtraTable = function (table) {
+      return new Uint8Array(table);
+    }([0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0, 0, 0]);
+    /**
+     * huffman dist code table.
+     * @const
+     * @type {!(Array.<number>|Uint16Array)}
+     */
+
+
+    Zlib.RawInflateStream.DistCodeTable = function (table) {
+      return new Uint16Array(table);
+    }([0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0007, 0x0009, 0x000d, 0x0011, 0x0019, 0x0021, 0x0031, 0x0041, 0x0061, 0x0081, 0x00c1, 0x0101, 0x0181, 0x0201, 0x0301, 0x0401, 0x0601, 0x0801, 0x0c01, 0x1001, 0x1801, 0x2001, 0x3001, 0x4001, 0x6001]);
+    /**
+     * huffman dist extra-bits table.
+     * @const
+     * @type {!(Array.<number>|Uint8Array)}
+     */
+
+
+    Zlib.RawInflateStream.DistExtraTable = function (table) {
+      return new Uint8Array(table);
+    }([0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13]);
+    /**
+     * fixed huffman length code table
+     * @const
+     * @type {!Array}
+     */
+
+
+    Zlib.RawInflateStream.FixedLiteralLengthTable = function (table) {
+      return table;
+    }(function () {
+      var lengths = new Uint8Array(288);
+      var i, il;
+
+      for (i = 0, il = lengths.length; i < il; ++i) {
+        lengths[i] = i <= 143 ? 8 : i <= 255 ? 9 : i <= 279 ? 7 : 8;
+      }
+
+      return buildHuffmanTable(lengths);
+    }());
+    /**
+     * fixed huffman distance code table
+     * @const
+     * @type {!Array}
+     */
+
+
+    Zlib.RawInflateStream.FixedDistanceTable = function (table) {
+      return table;
+    }(function () {
+      var lengths = new Uint8Array(30);
+      var i, il;
+
+      for (i = 0, il = lengths.length; i < il; ++i) {
+        lengths[i] = 5;
+      }
+
+      return buildHuffmanTable(lengths);
+    }());
+    /**
+     * parse deflated block.
+     */
+
+
+    Zlib.RawInflateStream.prototype.readBlockHeader = function () {
+      /** @type {number} header */
+      var hdr;
+      this.status = Zlib.RawInflateStream.Status.BLOCK_HEADER_START;
+      this.save_();
+
+      if ((hdr = this.readBits(3)) < 0) {
+        this.restore_();
+        return -1;
+      } // BFINAL
+
+
+      if (hdr & 0x1) {
+        this.bfinal = true;
+      } // BTYPE
+
+
+      hdr >>>= 1;
+
+      switch (hdr) {
+        case 0:
+          // uncompressed
+          this.currentBlockType = Zlib.RawInflateStream.BlockType.UNCOMPRESSED;
+          break;
+
+        case 1:
+          // fixed huffman
+          this.currentBlockType = Zlib.RawInflateStream.BlockType.FIXED;
+          break;
+
+        case 2:
+          // dynamic huffman
+          this.currentBlockType = Zlib.RawInflateStream.BlockType.DYNAMIC;
+          break;
+
+        default:
+          // reserved or other
+          throw new Error('unknown BTYPE: ' + hdr);
+      }
+
+      this.status = Zlib.RawInflateStream.Status.BLOCK_HEADER_END;
+    };
+    /**
+     * read inflate bits
+     * @param {number} length bits length.
+     * @return {number} read bits.
+     */
+
+
+    Zlib.RawInflateStream.prototype.readBits = function (length) {
+      var bitsbuf = this.bitsbuf;
+      var bitsbuflen = this.bitsbuflen;
+      var input = this.input;
+      var ip = this.ip;
+      /** @type {number} input and output byte. */
+
+      var octet; // not enough buffer
+
+      while (bitsbuflen < length) {
+        // input byte
+        if (input.length <= ip) {
+          return -1;
+        }
+
+        octet = input[ip++]; // concat octet
+
+        bitsbuf |= octet << bitsbuflen;
+        bitsbuflen += 8;
+      } // output byte
+
+
+      octet = bitsbuf & (1 << length) - 1;
+      bitsbuf >>>= length;
+      bitsbuflen -= length;
+      this.bitsbuf = bitsbuf;
+      this.bitsbuflen = bitsbuflen;
+      this.ip = ip;
+      return octet;
+    };
+    /**
+     * read huffman code using table
+     * @param {Array} table huffman code table.
+     * @return {number} huffman code.
+     */
+
+
+    Zlib.RawInflateStream.prototype.readCodeByTable = function (table) {
+      var bitsbuf = this.bitsbuf;
+      var bitsbuflen = this.bitsbuflen;
+      var input = this.input;
+      var ip = this.ip;
+      /** @type {!(Array|Uint8Array)} huffman code table */
+
+      var codeTable = table[0];
+      /** @type {number} */
+
+      var maxCodeLength = table[1];
+      /** @type {number} input byte */
+
+      var octet;
+      /** @type {number} code length & code (16bit, 16bit) */
+
+      var codeWithLength;
+      /** @type {number} code bits length */
+
+      var codeLength; // not enough buffer
+
+      while (bitsbuflen < maxCodeLength) {
+        if (input.length <= ip) {
+          return -1;
+        }
+
+        octet = input[ip++];
+        bitsbuf |= octet << bitsbuflen;
+        bitsbuflen += 8;
+      } // read max length
+
+
+      codeWithLength = codeTable[bitsbuf & (1 << maxCodeLength) - 1];
+      codeLength = codeWithLength >>> 16;
+
+      if (codeLength > bitsbuflen) {
+        throw new Error('invalid code length: ' + codeLength);
+      }
+
+      this.bitsbuf = bitsbuf >> codeLength;
+      this.bitsbuflen = bitsbuflen - codeLength;
+      this.ip = ip;
+      return codeWithLength & 0xffff;
+    };
+    /**
+     * read uncompressed block header
+     */
+
+
+    Zlib.RawInflateStream.prototype.readUncompressedBlockHeader = function () {
+      /** @type {number} block length */
+      var len;
+      /** @type {number} number for check block length */
+
+      var nlen;
+      var input = this.input;
+      var ip = this.ip;
+      this.status = Zlib.RawInflateStream.Status.BLOCK_BODY_START;
+
+      if (ip + 4 >= input.length) {
+        return -1;
+      }
+
+      len = input[ip++] | input[ip++] << 8;
+      nlen = input[ip++] | input[ip++] << 8; // check len & nlen
+
+      if (len === ~nlen) {
+        throw new Error('invalid uncompressed block header: length verify');
+      } // skip buffered header bits
+
+
+      this.bitsbuf = 0;
+      this.bitsbuflen = 0;
+      this.ip = ip;
+      this.blockLength = len;
+      this.status = Zlib.RawInflateStream.Status.BLOCK_BODY_END;
+    };
+    /**
+     * parse uncompressed block.
+     */
+
+
+    Zlib.RawInflateStream.prototype.parseUncompressedBlock = function () {
+      var input = this.input;
+      var ip = this.ip;
+      var output = this.output;
+      var op = this.op;
+      var len = this.blockLength;
+      this.status = Zlib.RawInflateStream.Status.DECODE_BLOCK_START; // copy
+      // XXX: ã¨ã‚Šã‚ãˆãšç´ ç›´ã«ã‚³ãƒ”ãƒ¼
+
+      while (len--) {
+        if (op === output.length) {
+          output = this.expandBuffer({
+            fixRatio: 2
+          });
+        } // not enough input buffer
+
+
+        if (ip >= input.length) {
+          this.ip = ip;
+          this.op = op;
+          this.blockLength = len + 1; // コピーしてないので戻す
+
+          return -1;
+        }
+
+        output[op++] = input[ip++];
+      }
+
+      if (len < 0) {
+        this.status = Zlib.RawInflateStream.Status.DECODE_BLOCK_END;
+      }
+
+      this.ip = ip;
+      this.op = op;
+      return 0;
+    };
+    /**
+     * parse fixed huffman block.
+     */
+
+
+    Zlib.RawInflateStream.prototype.parseFixedHuffmanBlock = function () {
+      this.status = Zlib.RawInflateStream.Status.BLOCK_BODY_START;
+      this.litlenTable = Zlib.RawInflateStream.FixedLiteralLengthTable;
+      this.distTable = Zlib.RawInflateStream.FixedDistanceTable;
+      this.status = Zlib.RawInflateStream.Status.BLOCK_BODY_END;
+      return 0;
+    };
+    /**
+     * オブジェクトのコンテキストを別のプロパティに退避する.
+     * @private
+     */
+
+
+    Zlib.RawInflateStream.prototype.save_ = function () {
+      this.ip_ = this.ip;
+      this.bitsbuflen_ = this.bitsbuflen;
+      this.bitsbuf_ = this.bitsbuf;
+    };
+    /**
+     * 別のプロパティに退避したコンテキストを復元する.
+     * @private
+     */
+
+
+    Zlib.RawInflateStream.prototype.restore_ = function () {
+      this.ip = this.ip_;
+      this.bitsbuflen = this.bitsbuflen_;
+      this.bitsbuf = this.bitsbuf_;
+    };
+    /**
+     * parse dynamic huffman block.
+     */
+
+
+    Zlib.RawInflateStream.prototype.parseDynamicHuffmanBlock = function () {
+      /** @type {number} number of literal and length codes. */
+      var hlit;
+      /** @type {number} number of distance codes. */
+
+      var hdist;
+      /** @type {number} number of code lengths. */
+
+      var hclen;
+      /** @type {!(Uint8Array|Array)} code lengths. */
+
+      var codeLengths = new Uint8Array(Zlib.RawInflateStream.Order.length);
+      /** @type {!Array} code lengths table. */
+
+      var codeLengthsTable;
+      this.status = Zlib.RawInflateStream.Status.BLOCK_BODY_START;
+      this.save_();
+      hlit = this.readBits(5) + 257;
+      hdist = this.readBits(5) + 1;
+      hclen = this.readBits(4) + 4;
+
+      if (hlit < 0 || hdist < 0 || hclen < 0) {
+        this.restore_();
+        return -1;
+      }
+
+      try {
+        parseDynamicHuffmanBlockImpl.call(this);
+      } catch (e) {
+        this.restore_();
+        return -1;
+      }
+
+      function parseDynamicHuffmanBlockImpl() {
+        /** @type {number} */
+        var bits;
+        var code;
+        var prev = 0;
+        var repeat;
+        /** @type {!(Uint8Array|Array.<number>)} code length table. */
+
+        var lengthTable;
+        /** @type {number} loop counter. */
+
+        var i;
+        /** @type {number} loop limit. */
+
+        var il; // decode code lengths
+
+        for (i = 0; i < hclen; ++i) {
+          if ((bits = this.readBits(3)) < 0) {
+            throw new Error('not enough input');
+          }
+
+          codeLengths[Zlib.RawInflateStream.Order[i]] = bits;
+        } // decode length table
+
+
+        codeLengthsTable = buildHuffmanTable(codeLengths);
+        lengthTable = new Uint8Array(hlit + hdist);
+
+        for (i = 0, il = hlit + hdist; i < il;) {
+          code = this.readCodeByTable(codeLengthsTable);
+
+          if (code < 0) {
+            throw new Error('not enough input');
+          }
+
+          switch (code) {
+            case 16:
+              if ((bits = this.readBits(2)) < 0) {
+                throw new Error('not enough input');
+              }
+
+              repeat = 3 + bits;
+
+              while (repeat--) {
+                lengthTable[i++] = prev;
+              }
+
+              break;
+
+            case 17:
+              if ((bits = this.readBits(3)) < 0) {
+                throw new Error('not enough input');
+              }
+
+              repeat = 3 + bits;
+
+              while (repeat--) {
+                lengthTable[i++] = 0;
+              }
+
+              prev = 0;
+              break;
+
+            case 18:
+              if ((bits = this.readBits(7)) < 0) {
+                throw new Error('not enough input');
+              }
+
+              repeat = 11 + bits;
+
+              while (repeat--) {
+                lengthTable[i++] = 0;
+              }
+
+              prev = 0;
+              break;
+
+            default:
+              lengthTable[i++] = code;
+              prev = code;
+              break;
+          }
+        }
+
+        this.litlenTable = buildHuffmanTable(lengthTable.subarray(0, hlit));
+        this.distTable = buildHuffmanTable(lengthTable.subarray(hlit));
+      }
+
+      this.status = Zlib.RawInflateStream.Status.BLOCK_BODY_END;
+      return 0;
+    };
+    /**
+     * decode huffman code (dynamic)
+     * @return {(number|undefined)} -1 is error.
+     */
+
+
+    Zlib.RawInflateStream.prototype.decodeHuffman = function () {
+      var output = this.output;
+      var op = this.op;
+      /** @type {number} huffman code. */
+
+      var code;
+      /** @type {number} table index. */
+
+      var ti;
+      /** @type {number} huffman code distination. */
+
+      var codeDist;
+      /** @type {number} huffman code length. */
+
+      var codeLength;
+      var litlen = this.litlenTable;
+      var dist = this.distTable;
+      var olength = output.length;
+      var bits;
+      this.status = Zlib.RawInflateStream.Status.DECODE_BLOCK_START;
+
+      while (true) {
+        this.save_();
+        code = this.readCodeByTable(litlen);
+
+        if (code < 0) {
+          this.op = op;
+          this.restore_();
+          return -1;
+        }
+
+        if (code === 256) {
+          break;
+        } // literal
+
+
+        if (code < 256) {
+          if (op === olength) {
+            output = this.expandBuffer();
+            olength = output.length;
+          }
+
+          output[op++] = code;
+          continue;
+        } // length code
+
+
+        ti = code - 257;
+        codeLength = Zlib.RawInflateStream.LengthCodeTable[ti];
+
+        if (Zlib.RawInflateStream.LengthExtraTable[ti] > 0) {
+          bits = this.readBits(Zlib.RawInflateStream.LengthExtraTable[ti]);
+
+          if (bits < 0) {
+            this.op = op;
+            this.restore_();
+            return -1;
+          }
+
+          codeLength += bits;
+        } // dist code
+
+
+        code = this.readCodeByTable(dist);
+
+        if (code < 0) {
+          this.op = op;
+          this.restore_();
+          return -1;
+        }
+
+        codeDist = Zlib.RawInflateStream.DistCodeTable[code];
+
+        if (Zlib.RawInflateStream.DistExtraTable[code] > 0) {
+          bits = this.readBits(Zlib.RawInflateStream.DistExtraTable[code]);
+
+          if (bits < 0) {
+            this.op = op;
+            this.restore_();
+            return -1;
+          }
+
+          codeDist += bits;
+        } // lz77 decode
+
+
+        if (op + codeLength >= olength) {
+          output = this.expandBuffer();
+          olength = output.length;
+        }
+
+        while (codeLength--) {
+          output[op] = output[op++ - codeDist];
+        } // break
+
+
+        if (this.ip === this.input.length) {
+          this.op = op;
+          return -1;
+        }
+      }
+
+      while (this.bitsbuflen >= 8) {
+        this.bitsbuflen -= 8;
+        this.ip--;
+      }
+
+      this.op = op;
+      this.status = Zlib.RawInflateStream.Status.DECODE_BLOCK_END;
+    };
+    /**
+     * expand output buffer. (dynamic)
+     * @param {Object=} opt_param option parameters.
+     * @return {!(Array|Uint8Array)} output buffer pointer.
+     */
+
+
+    Zlib.RawInflateStream.prototype.expandBuffer = function (opt_param) {
+      /** @type {!(Array|Uint8Array)} store buffer. */
+      var buffer;
+      /** @type {number} expantion ratio. */
+
+      var ratio = this.input.length / this.ip + 1 | 0;
+      /** @type {number} maximum number of huffman code. */
+
+      var maxHuffCode;
+      /** @type {number} new output buffer size. */
+
+      var newSize;
+      /** @type {number} max inflate size. */
+
+      var maxInflateSize;
+      var input = this.input;
+      var output = this.output;
+
+      if (opt_param) {
+        if (typeof opt_param.fixRatio === 'number') {
+          ratio = opt_param.fixRatio;
+        }
+
+        if (typeof opt_param.addRatio === 'number') {
+          ratio += opt_param.addRatio;
+        }
+      } // calculate new buffer size
+
+
+      if (ratio < 2) {
+        maxHuffCode = (input.length - this.ip) / this.litlenTable[2];
+        maxInflateSize = maxHuffCode / 2 * 258 | 0;
+        newSize = maxInflateSize < output.length ? output.length + maxInflateSize : output.length << 1;
+      } else {
+        newSize = output.length * ratio;
+      } // buffer expantion
+
+
+      {
+        buffer = new Uint8Array(newSize);
+        buffer.set(output);
+      }
+      this.output = buffer;
+      return this.output;
+    };
+    /**
+     * concat output buffer. (dynamic)
+     * @return {!(Array|Uint8Array)} output buffer.
+     */
+
+
+    Zlib.RawInflateStream.prototype.concatBuffer = function () {
+      /** @type {!(Array|Uint8Array)} output buffer. */
+      var buffer;
+      /** @type {number} */
+
+      var op = this.op;
+      /** @type {Uint8Array} */
+
+      var tmp;
+
+      if (this.resize) {
+        {
+          buffer = new Uint8Array(this.output.subarray(this.sp, op));
+        }
+      } else {
+        buffer = this.output.subarray(this.sp, op);
+      }
+
+      this.sp = op; // compaction
+
+      if (op > Zlib.RawInflateStream.MaxBackwardLength + this.bufferSize) {
+        this.op = this.sp = Zlib.RawInflateStream.MaxBackwardLength;
+        {
+          tmp = this.output;
+          this.output = new Uint8Array(this.bufferSize + Zlib.RawInflateStream.MaxBackwardLength);
+          this.output.set(tmp.subarray(op - Zlib.RawInflateStream.MaxBackwardLength, op));
+        }
+      }
+
+      return buffer;
+    };
+    /**
+     * @constructor
+     * @param {!(Uint8Array|Array)} input deflated buffer.
+     * @param {Object=} opt_params option parameters.
+     *
+     * opt_params は以下のプロパティを指定する事ができます。
+     *   - index: input buffer の deflate コンテナの開始位置.
+     *   - blockSize: バッファのブロックサイズ.
+     *   - verify: 伸張が終わった後 adler-32 checksum の検証を行うか.
+     *   - bufferType: Zlib.Inflate.BufferType の値によってバッファの管理方法を指定する.
+     *       Zlib.Inflate.BufferType は Zlib.RawInflate.BufferType のエイリアス.
+     */
+
+
+    Zlib.Inflate = function (input, opt_params) {
+      /** @type {number} */
+      var cmf;
+      /** @type {number} */
+
+      var flg;
+      /** @type {!(Uint8Array|Array)} */
+
+      this.input = input;
+      /** @type {number} */
+
+      this.ip = 0;
+      /** @type {Zlib.RawInflate} */
+
+      this.rawinflate;
+      /** @type {(boolean|undefined)} verify flag. */
+
+      this.verify; // option parameters
+
+      if (opt_params || !(opt_params = {})) {
+        if (opt_params['index']) {
+          this.ip = opt_params['index'];
+        }
+
+        if (opt_params['verify']) {
+          this.verify = opt_params['verify'];
+        }
+      } // Compression Method and Flags
+
+
+      cmf = input[this.ip++];
+      flg = input[this.ip++]; // compression method
+
+      switch (cmf & 0x0f) {
+        case Zlib.CompressionMethod.DEFLATE:
+          this.method = Zlib.CompressionMethod.DEFLATE;
+          break;
+
+        default:
+          throw new Error('unsupported compression method');
+      } // fcheck
+
+
+      if (((cmf << 8) + flg) % 31 !== 0) {
+        throw new Error('invalid fcheck flag:' + ((cmf << 8) + flg) % 31);
+      } // fdict (not supported)
+
+
+      if (flg & 0x20) {
+        throw new Error('fdict flag is not supported');
+      } // RawInflate
+
+
+      this.rawinflate = new Zlib.RawInflate(input, {
+        'index': this.ip,
+        'bufferSize': opt_params['bufferSize'],
+        'bufferType': opt_params['bufferType'],
+        'resize': opt_params['resize']
+      });
+    };
+    /**
+     * @enum {number}
+     */
+
+
+    Zlib.Inflate.BufferType = Zlib.RawInflate.BufferType;
+    /**
+     * decompress.
+     * @return {!(Uint8Array|Array)} inflated buffer.
+     */
+
+    Zlib.Inflate.prototype.decompress = function () {
+      /** @type {!(Array|Uint8Array)} input buffer. */
+      var input = this.input;
+      /** @type {!(Uint8Array|Array)} inflated buffer. */
+
+      var buffer;
+      /** @type {number} adler-32 checksum */
+
+      var adler32;
+      buffer = this.rawinflate.decompress();
+      this.ip = this.rawinflate.ip; // verify adler-32
+
+      if (this.verify) {
+        adler32 = (input[this.ip++] << 24 | input[this.ip++] << 16 | input[this.ip++] << 8 | input[this.ip++]) >>> 0;
+
+        if (adler32 !== Zlib.Adler32(buffer)) {
+          throw new Error('invalid adler-32 checksum');
+        }
+      }
+
+      return buffer;
+    };
+    /* vim:set expandtab ts=2 sw=2 tw=80: */
+
+    /**
+     * @param {!(Uint8Array|Array)} input deflated buffer.
+     * @constructor
+     */
+
+
+    Zlib.InflateStream = function (input) {
+      /** @type {!(Uint8Array|Array)} */
+      this.input = input === void 0 ? new Uint8Array() : input;
+      /** @type {number} */
+
+      this.ip = 0;
+      /** @type {Zlib.RawInflateStream} */
+
+      this.rawinflate = new Zlib.RawInflateStream(this.input, this.ip);
+      /** @type {Zlib.CompressionMethod} */
+
+      this.method;
+      /** @type {!(Array|Uint8Array)} */
+
+      this.output = this.rawinflate.output;
+    };
+    /**
+     * decompress.
+     * @return {!(Uint8Array|Array)} inflated buffer.
+     */
+
+
+    Zlib.InflateStream.prototype.decompress = function (input) {
+      /** @type {!(Uint8Array|Array)} inflated buffer. */
+      var buffer; // 新しい入力を入力バッファに結合する
+      // XXX Array, Uint8Array のチェックを行うか確認する
+
+      if (input !== void 0) {
+        {
+          var tmp = new Uint8Array(this.input.length + input.length);
+          tmp.set(this.input, 0);
+          tmp.set(input, this.input.length);
+          this.input = tmp;
+        }
+      }
+
+      if (this.method === void 0) {
+        if (this.readHeader() < 0) {
+          return new Uint8Array();
+        }
+      }
+
+      buffer = this.rawinflate.decompress(this.input, this.ip);
+
+      if (this.rawinflate.ip !== 0) {
+        this.input = this.input.subarray(this.rawinflate.ip);
+        this.ip = 0;
+      } // verify adler-32
+
+      /*
+      if (this.verify) {
+        adler32 =
+          input[this.ip++] << 24 | input[this.ip++] << 16 |
+          input[this.ip++] << 8 | input[this.ip++];
+         if (adler32 !== Zlib.Adler32(buffer)) {
+          throw new Error('invalid adler-32 checksum');
+        }
+      }
+      */
+
+
+      return buffer;
+    };
+
+    Zlib.InflateStream.prototype.readHeader = function () {
+      var ip = this.ip;
+      var input = this.input; // Compression Method and Flags
+
+      var cmf = input[ip++];
+      var flg = input[ip++];
+
+      if (cmf === void 0 || flg === void 0) {
+        return -1;
+      } // compression method
+
+
+      switch (cmf & 0x0f) {
+        case Zlib.CompressionMethod.DEFLATE:
+          this.method = Zlib.CompressionMethod.DEFLATE;
+          break;
+
+        default:
+          throw new Error('unsupported compression method');
+      } // fcheck
+
+
+      if (((cmf << 8) + flg) % 31 !== 0) {
+        throw new Error('invalid fcheck flag:' + ((cmf << 8) + flg) % 31);
+      } // fdict (not supported)
+
+
+      if (flg & 0x20) {
+        throw new Error('fdict flag is not supported');
+      }
+
+      this.ip = ip;
+    };
+    /**
+     * @fileoverview GZIP (RFC1952) 展開コンテナ実装.
+     */
+
+    /**
+     * @constructor
+     * @param {!(Array|Uint8Array)} input input buffer.
+     * @param {Object=} opt_params option parameters.
+     */
+
+
+    Zlib.Gunzip = function (input, opt_params) {
+      /** @type {!(Array.<number>|Uint8Array)} input buffer. */
+      this.input = input;
+      /** @type {number} input buffer pointer. */
+
+      this.ip = 0;
+      /** @type {Array.<Zlib.GunzipMember>} */
+
+      this.member = [];
+      /** @type {boolean} */
+
+      this.decompressed = false;
+    };
+    /**
+     * @return {Array.<Zlib.GunzipMember>}
+     */
+
+
+    Zlib.Gunzip.prototype.getMembers = function () {
+      if (!this.decompressed) {
+        this.decompress();
+      }
+
+      return this.member.slice();
+    };
+    /**
+     * inflate gzip data.
+     * @return {!(Array.<number>|Uint8Array)} inflated buffer.
+     */
+
+
+    Zlib.Gunzip.prototype.decompress = function () {
+      /** @type {number} input length. */
+      var il = this.input.length;
+
+      while (this.ip < il) {
+        this.decodeMember();
+      }
+
+      this.decompressed = true;
+      return this.concatMember();
+    };
+    /**
+     * decode gzip member.
+     */
+
+
+    Zlib.Gunzip.prototype.decodeMember = function () {
+      /** @type {Zlib.GunzipMember} */
+      var member = new Zlib.GunzipMember();
+      /** @type {number} */
+
+      var isize;
+      /** @type {Zlib.RawInflate} RawInflate implementation. */
+
+      var rawinflate;
+      /** @type {!(Array.<number>|Uint8Array)} inflated data. */
+
+      var inflated;
+      /** @type {number} inflate size */
+
+      var inflen;
+      /** @type {number} character code */
+
+      var c;
+      /** @type {number} character index in string. */
+
+      var ci;
+      /** @type {Array.<string>} character array. */
+
+      var str;
+      /** @type {number} modification time. */
+
+      var mtime;
+      /** @type {number} */
+
+      var crc32;
+      var input = this.input;
+      var ip = this.ip;
+      member.id1 = input[ip++];
+      member.id2 = input[ip++]; // check signature
+
+      if (member.id1 !== 0x1f || member.id2 !== 0x8b) {
+        throw new Error('invalid file signature:' + member.id1 + ',' + member.id2);
+      } // check compression method
+
+
+      member.cm = input[ip++];
+
+      switch (member.cm) {
+        case 8:
+          /* XXX: use Zlib const */
+          break;
+
+        default:
+          throw new Error('unknown compression method: ' + member.cm);
+      } // flags
+
+
+      member.flg = input[ip++]; // modification time
+
+      mtime = input[ip++] | input[ip++] << 8 | input[ip++] << 16 | input[ip++] << 24;
+      member.mtime = new Date(mtime * 1000); // extra flags
+
+      member.xfl = input[ip++]; // operating system
+
+      member.os = input[ip++]; // extra
+
+      if ((member.flg & Zlib.Gzip.FlagsMask.FEXTRA) > 0) {
+        member.xlen = input[ip++] | input[ip++] << 8;
+        ip = this.decodeSubField(ip, member.xlen);
+      } // fname
+
+
+      if ((member.flg & Zlib.Gzip.FlagsMask.FNAME) > 0) {
+        for (str = [], ci = 0; (c = input[ip++]) > 0;) {
+          str[ci++] = String.fromCharCode(c);
+        }
+
+        member.name = str.join('');
+      } // fcomment
+
+
+      if ((member.flg & Zlib.Gzip.FlagsMask.FCOMMENT) > 0) {
+        for (str = [], ci = 0; (c = input[ip++]) > 0;) {
+          str[ci++] = String.fromCharCode(c);
+        }
+
+        member.comment = str.join('');
+      } // fhcrc
+
+
+      if ((member.flg & Zlib.Gzip.FlagsMask.FHCRC) > 0) {
+        member.crc16 = Zlib.CRC32.calc(input, 0, ip) & 0xffff;
+
+        if (member.crc16 !== (input[ip++] | input[ip++] << 8)) {
+          throw new Error('invalid header crc16');
+        }
+      } // isize を事前に取得すると展開後のサイズが分かるため、
+      // inflate処理のバッファサイズが事前に分かり、高速になる
+
+
+      isize = input[input.length - 4] | input[input.length - 3] << 8 | input[input.length - 2] << 16 | input[input.length - 1] << 24; // isize の妥当性チェック
+      // ハフマン符号では最小 2-bit のため、最大で 1/4 になる
+      // LZ77 符号では 長さと距離 2-Byte で最大 258-Byte を表現できるため、
+      // 1/128 になるとする
+      // ここから入力バッファの残りが isize の 512 倍以上だったら
+      // サイズ指定のバッファ確保は行わない事とする
+
+      if (input.length - ip -
+      /* CRC-32 */
+      4 -
+      /* ISIZE */
+      4 < isize * 512) {
+        inflen = isize;
+      } // compressed block
+
+
+      rawinflate = new Zlib.RawInflate(input, {
+        'index': ip,
+        'bufferSize': inflen
+      });
+      member.data = inflated = rawinflate.decompress();
+      ip = rawinflate.ip; // crc32
+
+      member.crc32 = crc32 = (input[ip++] | input[ip++] << 8 | input[ip++] << 16 | input[ip++] << 24) >>> 0;
+
+      if (Zlib.CRC32.calc(inflated) !== crc32) {
+        throw new Error('invalid CRC-32 checksum: 0x' + Zlib.CRC32.calc(inflated).toString(16) + ' / 0x' + crc32.toString(16));
+      } // input size
+
+
+      member.isize = isize = (input[ip++] | input[ip++] << 8 | input[ip++] << 16 | input[ip++] << 24) >>> 0;
+
+      if ((inflated.length & 0xffffffff) !== isize) {
+        throw new Error('invalid input size: ' + (inflated.length & 0xffffffff) + ' / ' + isize);
+      }
+
+      this.member.push(member);
+      this.ip = ip;
+    };
+    /**
+     * サブフィールドのデコード
+     * XXX: 現在は何もせずスキップする
+     */
+
+
+    Zlib.Gunzip.prototype.decodeSubField = function (ip, length) {
+      return ip + length;
+    };
+    /**
+     * @return {!(Array.<number>|Uint8Array)}
+     */
+
+
+    Zlib.Gunzip.prototype.concatMember = function () {
+      /** @type {Array.<Zlib.GunzipMember>} */
+      var member = this.member;
+      /** @type {number} */
+
+      var i;
+      /** @type {number} */
+
+      var il;
+      /** @type {number} */
+
+      var p = 0;
+      /** @type {number} */
+
+      var size = 0;
+      /** @type {!(Array.<number>|Uint8Array)} */
+
+      var buffer;
+
+      for (i = 0, il = member.length; i < il; ++i) {
+        size += member[i].data.length;
+      }
+
+      {
+        buffer = new Uint8Array(size);
+
+        for (i = 0; i < il; ++i) {
+          buffer.set(member[i].data, p);
+          p += member[i].data.length;
+        }
+      }
+      return buffer;
+    };
+    /**
+     * @constructor
+     */
+
+
+    Zlib.GunzipMember = function () {
+      /** @type {number} signature first byte. */
+      this.id1;
+      /** @type {number} signature second byte. */
+
+      this.id2;
+      /** @type {number} compression method. */
+
+      this.cm;
+      /** @type {number} flags. */
+
+      this.flg;
+      /** @type {Date} modification time. */
+
+      this.mtime;
+      /** @type {number} extra flags. */
+
+      this.xfl;
+      /** @type {number} operating system number. */
+
+      this.os;
+      /** @type {number} CRC-16 value for FHCRC flag. */
+
+      this.crc16;
+      /** @type {number} extra length. */
+
+      this.xlen;
+      /** @type {number} CRC-32 value for verification. */
+
+      this.crc32;
+      /** @type {number} input size modulo 32 value. */
+
+      this.isize;
+      /** @type {string} filename. */
+
+      this.name;
+      /** @type {string} comment. */
+
+      this.comment;
+      /** @type {!(Uint8Array|Array.<number>)} */
+
+      this.data;
+    };
+
+    Zlib.GunzipMember.prototype.getName = function () {
+      return this.name;
+    };
+
+    Zlib.GunzipMember.prototype.getData = function () {
+      return this.data;
+    };
+
+    Zlib.GunzipMember.prototype.getMtime = function () {
+      return this.mtime;
+    };
+    /**
+     * @fileoverview GZIP (RFC1952) 実装.
+     */
+
+    /**
+     * @constructor
+     * @param {!(Array|Uint8Array)} input input buffer.
+     * @param {Object=} opt_params option parameters.
+     */
+
+
+    Zlib.Gzip = function (input, opt_params) {
+      /** @type {!(Array.<number>|Uint8Array)} input buffer. */
+      this.input = input;
+      /** @type {number} input buffer pointer. */
+
+      this.ip = 0;
+      /** @type {!(Array.<number>|Uint8Array)} output buffer. */
+
+      this.output;
+      /** @type {number} output buffer. */
+
+      this.op = 0;
+      /** @type {!Object} flags option flags. */
+
+      this.flags = {};
+      /** @type {!string} filename. */
+
+      this.filename;
+      /** @type {!string} comment. */
+
+      this.comment;
+      /** @type {!Object} deflate options. */
+
+      this.deflateOptions; // option parameters
+
+      if (opt_params) {
+        if (opt_params['flags']) {
+          this.flags = opt_params['flags'];
+        }
+
+        if (typeof opt_params['filename'] === 'string') {
+          this.filename = opt_params['filename'];
+        }
+
+        if (typeof opt_params['comment'] === 'string') {
+          this.comment = opt_params['comment'];
+        }
+
+        if (opt_params['deflateOptions']) {
+          this.deflateOptions = opt_params['deflateOptions'];
+        }
+      }
+
+      if (!this.deflateOptions) {
+        this.deflateOptions = {};
+      }
+    };
+    /**
+     * @type {number}
+     * @const
+     */
+
+
+    Zlib.Gzip.DefaultBufferSize = 0x8000;
+    /**
+     * encode gzip members.
+     * @return {!(Array|Uint8Array)} gzip binary array.
+     */
+
+    Zlib.Gzip.prototype.compress = function () {
+      /** @type {number} flags. */
+      var flg;
+      /** @type {number} modification time. */
+
+      var mtime;
+      /** @type {number} CRC-16 value for FHCRC flag. */
+
+      var crc16;
+      /** @type {number} CRC-32 value for verification. */
+
+      var crc32;
+      /** @type {!Zlib.RawDeflate} raw deflate object. */
+
+      var rawdeflate;
+      /** @type {number} character code */
+
+      var c;
+      /** @type {number} loop counter. */
+
+      var i;
+      /** @type {number} loop limiter. */
+
+      var il;
+      /** @type {!(Array|Uint8Array)} output buffer. */
+
+      var output = new Uint8Array(Zlib.Gzip.DefaultBufferSize);
+      /** @type {number} output buffer pointer. */
+
+      var op = 0;
+      var input = this.input;
+      var ip = this.ip;
+      var filename = this.filename;
+      var comment = this.comment; // check signature
+
+      output[op++] = 0x1f;
+      output[op++] = 0x8b; // check compression method
+
+      output[op++] = 8;
+      /* XXX: use Zlib const */
+      // flags
+
+      flg = 0;
+      if (this.flags['fname']) flg |= Zlib.Gzip.FlagsMask.FNAME;
+      if (this.flags['fcomment']) flg |= Zlib.Gzip.FlagsMask.FCOMMENT;
+      if (this.flags['fhcrc']) flg |= Zlib.Gzip.FlagsMask.FHCRC; // XXX: FTEXT
+      // XXX: FEXTRA
+
+      output[op++] = flg; // modification time
+
+      mtime = (Date.now ? Date.now() : +new Date()) / 1000 | 0;
+      output[op++] = mtime & 0xff;
+      output[op++] = mtime >>> 8 & 0xff;
+      output[op++] = mtime >>> 16 & 0xff;
+      output[op++] = mtime >>> 24 & 0xff; // extra flags
+
+      output[op++] = 0; // operating system
+
+      output[op++] = Zlib.Gzip.OperatingSystem.UNKNOWN; // extra
+
+      /* NOP */
+      // fname
+
+      if (this.flags['fname'] !== void 0) {
+        for (i = 0, il = filename.length; i < il; ++i) {
+          c = filename.charCodeAt(i);
+
+          if (c > 0xff) {
+            output[op++] = c >>> 8 & 0xff;
+          }
+
+          output[op++] = c & 0xff;
+        }
+
+        output[op++] = 0; // null termination
+      } // fcomment
+
+
+      if (this.flags['comment']) {
+        for (i = 0, il = comment.length; i < il; ++i) {
+          c = comment.charCodeAt(i);
+
+          if (c > 0xff) {
+            output[op++] = c >>> 8 & 0xff;
+          }
+
+          output[op++] = c & 0xff;
+        }
+
+        output[op++] = 0; // null termination
+      } // fhcrc
+
+
+      if (this.flags['fhcrc']) {
+        crc16 = Zlib.CRC32.calc(output, 0, op) & 0xffff;
+        output[op++] = crc16 & 0xff;
+        output[op++] = crc16 >>> 8 & 0xff;
+      } // add compress option
+
+
+      this.deflateOptions['outputBuffer'] = output;
+      this.deflateOptions['outputIndex'] = op; // compress
+
+      rawdeflate = new Zlib.RawDeflate(input, this.deflateOptions);
+      output = rawdeflate.compress();
+      op = rawdeflate.op; // expand buffer
+
+      {
+        if (op + 8 > output.buffer.byteLength) {
+          this.output = new Uint8Array(op + 8);
+          this.output.set(new Uint8Array(output.buffer));
+          output = this.output;
+        } else {
+          output = new Uint8Array(output.buffer);
+        }
+      } // crc32
+
+      crc32 = Zlib.CRC32.calc(input);
+      output[op++] = crc32 & 0xff;
+      output[op++] = crc32 >>> 8 & 0xff;
+      output[op++] = crc32 >>> 16 & 0xff;
+      output[op++] = crc32 >>> 24 & 0xff; // input size
+
+      il = input.length;
+      output[op++] = il & 0xff;
+      output[op++] = il >>> 8 & 0xff;
+      output[op++] = il >>> 16 & 0xff;
+      output[op++] = il >>> 24 & 0xff;
+      this.ip = ip;
+
+      if (op < output.length) {
+        this.output = output = output.subarray(0, op);
+      }
+
+      return output;
+    };
+    /** @enum {number} */
+
+
+    Zlib.Gzip.OperatingSystem = {
+      FAT: 0,
+      AMIGA: 1,
+      VMS: 2,
+      UNIX: 3,
+      VM_CMS: 4,
+      ATARI_TOS: 5,
+      HPFS: 6,
+      MACINTOSH: 7,
+      Z_SYSTEM: 8,
+      CP_M: 9,
+      TOPS_20: 10,
+      NTFS: 11,
+      QDOS: 12,
+      ACORN_RISCOS: 13,
+      UNKNOWN: 255
+    };
+    /** @enum {number} */
+
+    Zlib.Gzip.FlagsMask = {
+      FTEXT: 0x01,
+      FHCRC: 0x02,
+      FEXTRA: 0x04,
+      FNAME: 0x08,
+      FCOMMENT: 0x10
+    };
+    /**
+     * @fileoverview Heap Sort 実装. ハフマン符号化で使用する.
+     */
+
+    /**
+     * カスタムハフマン符号で使用するヒープ実装
+     * @param {number} length ヒープサイズ.
+     * @constructor
+     */
+
+    Zlib.Heap = function (length) {
+      this.buffer = new Uint16Array(length * 2);
+      this.length = 0;
+    };
+    /**
+     * 親ノードの index 取得
+     * @param {number} index 子ノードの index.
+     * @return {number} 親ノードの index.
+     *
+     */
+
+
+    Zlib.Heap.prototype.getParent = function (index) {
+      return ((index - 2) / 4 | 0) * 2;
+    };
+    /**
+     * 子ノードの index 取得
+     * @param {number} index 親ノードの index.
+     * @return {number} 子ノードの index.
+     */
+
+
+    Zlib.Heap.prototype.getChild = function (index) {
+      return 2 * index + 2;
+    };
+    /**
+     * Heap ã«å€¤ã‚’è¿½åŠ ã™ã‚‹
+     * @param {number} index キー index.
+     * @param {number} value 値.
+     * @return {number} 現在のヒープ長.
+     */
+
+
+    Zlib.Heap.prototype.push = function (index, value) {
+      var current,
+          parent,
+          heap = this.buffer,
+          swap;
+      current = this.length;
+      heap[this.length++] = value;
+      heap[this.length++] = index; // ルートノードにたどり着くまで入れ替えを試みる
+
+      while (current > 0) {
+        parent = this.getParent(current); // 親ノードと比較して親の方が小さければ入れ替える
+
+        if (heap[current] > heap[parent]) {
+          swap = heap[current];
+          heap[current] = heap[parent];
+          heap[parent] = swap;
+          swap = heap[current + 1];
+          heap[current + 1] = heap[parent + 1];
+          heap[parent + 1] = swap;
+          current = parent; // 入れ替えが必要なくなったらそこで抜ける
+        } else {
+          break;
+        }
+      }
+
+      return this.length;
+    };
+    /**
+     * Heapから一番大きい値を返す
+     * @return {{index: number, value: number, length: number}} {index: キーindex,
+     *     value: 値, length: ヒープ長} の Object.
+     */
+
+
+    Zlib.Heap.prototype.pop = function () {
+      var index,
+          value,
+          heap = this.buffer,
+          swap,
+          current,
+          parent;
+      value = heap[0];
+      index = heap[1]; // 後ろから値を取る
+
+      this.length -= 2;
+      heap[0] = heap[this.length];
+      heap[1] = heap[this.length + 1];
+      parent = 0; // ルートノードから下がっていく
+
+      while (true) {
+        current = this.getChild(parent); // 範囲チェック
+
+        if (current >= this.length) {
+          break;
+        } // 隣のノードと比較して、隣の方が値が大きければ隣を現在ノードとして選択
+
+
+        if (current + 2 < this.length && heap[current + 2] > heap[current]) {
+          current += 2;
+        } // è¦ªãƒŽãƒ¼ãƒ‰ã¨æ¯”è¼ƒã—ã¦è¦ªã®æ–¹ãŒå°ã•ã„å ´åˆã¯å…¥ã‚Œæ›¿ãˆã‚‹
+
+
+        if (heap[current] > heap[parent]) {
+          swap = heap[parent];
+          heap[parent] = heap[current];
+          heap[current] = swap;
+          swap = heap[parent + 1];
+          heap[parent + 1] = heap[current + 1];
+          heap[current + 1] = swap;
+        } else {
+          break;
+        }
+
+        parent = current;
+      }
+
+      return {
+        index: index,
+        value: value,
+        length: this.length
+      };
+    };
+    /* vim:set expandtab ts=2 sw=2 tw=80: */
+
+    /**
+     * @fileoverview Deflate (RFC1951) 符号化アルゴリズム実装.
+     */
+
+    /**
+     * Raw Deflate 実装
+     *
+     * @constructor
+     * @param {!(Array.<number>|Uint8Array)} input 符号化する対象のバッファ.
+     * @param {Object=} opt_params option parameters.
+     *
+     * typed array が使用可能なとき、outputBuffer が Array は自動的に Uint8Array に
+     * 変換されます.
+     * 別のオブジェクトになるため出力バッファを参照している変数などは
+     * 更新する必要があります.
+     */
+
+
+    Zlib.RawDeflate = function (input, opt_params) {
+      /** @type {Zlib.RawDeflate.CompressionType} */
+      this.compressionType = Zlib.RawDeflate.CompressionType.DYNAMIC;
+      /** @type {number} */
+
+      this.lazy = 0;
+      /** @type {!(Array.<number>|Uint32Array)} */
+
+      this.freqsLitLen;
+      /** @type {!(Array.<number>|Uint32Array)} */
+
+      this.freqsDist;
+      /** @type {!(Array.<number>|Uint8Array)} */
+
+      this.input = input instanceof Array ? new Uint8Array(input) : input;
+      /** @type {!(Array.<number>|Uint8Array)} output output buffer. */
+
+      this.output;
+      /** @type {number} pos output buffer position. */
+
+      this.op = 0; // option parameters
+
+      if (opt_params) {
+        if (opt_params['lazy']) {
+          this.lazy = opt_params['lazy'];
+        }
+
+        if (typeof opt_params['compressionType'] === 'number') {
+          this.compressionType = opt_params['compressionType'];
+        }
+
+        if (opt_params['outputBuffer']) {
+          this.output = opt_params['outputBuffer'] instanceof Array ? new Uint8Array(opt_params['outputBuffer']) : opt_params['outputBuffer'];
+        }
+
+        if (typeof opt_params['outputIndex'] === 'number') {
+          this.op = opt_params['outputIndex'];
+        }
+      }
+
+      if (!this.output) {
+        this.output = new Uint8Array(0x8000);
+      }
+    };
+    /**
+     * @enum {number}
+     */
+
+
+    Zlib.RawDeflate.CompressionType = {
+      NONE: 0,
+      FIXED: 1,
+      DYNAMIC: 2,
+      RESERVED: 3
+    };
+    /**
+     * LZ77 の最小マッチ長
+     * @const
+     * @type {number}
+     */
+
+    Zlib.RawDeflate.Lz77MinLength = 3;
+    /**
+     * LZ77 の最大マッチ長
+     * @const
+     * @type {number}
+     */
+
+    Zlib.RawDeflate.Lz77MaxLength = 258;
+    /**
+     * LZ77 のウィンドウサイズ
+     * @const
+     * @type {number}
+     */
+
+    Zlib.RawDeflate.WindowSize = 0x8000;
+    /**
+     * 最長の符号長
+     * @const
+     * @type {number}
+     */
+
+    Zlib.RawDeflate.MaxCodeLength = 16;
+    /**
+     * ハフマン符号の最大数値
+     * @const
+     * @type {number}
+     */
+
+    Zlib.RawDeflate.HUFMAX = 286;
+    /**
+     * 固定ハフマン符号の符号化テーブル
+     * @const
+     * @type {Array.<Array.<number, number>>}
+     */
+
+    Zlib.RawDeflate.FixedHuffmanTable = function () {
+      var table = [],
+          i;
+
+      for (i = 0; i < 288; i++) {
+        switch (true) {
+          case i <= 143:
+            table.push([i + 0x030, 8]);
+            break;
+
+          case i <= 255:
+            table.push([i - 144 + 0x190, 9]);
+            break;
+
+          case i <= 279:
+            table.push([i - 256 + 0x000, 7]);
+            break;
+
+          case i <= 287:
+            table.push([i - 280 + 0x0C0, 8]);
+            break;
+
+          default:
+            throw 'invalid literal: ' + i;
+        }
+      }
+
+      return table;
+    }();
+    /**
+     * DEFLATE ブロックの作成
+     * @return {!(Array.<number>|Uint8Array)} 圧縮済み byte array.
+     */
+
+
+    Zlib.RawDeflate.prototype.compress = function () {
+      /** @type {!(Array.<number>|Uint8Array)} */
+      var blockArray;
+      /** @type {number} */
+
+      var position;
+      /** @type {number} */
+
+      var length;
+      var input = this.input; // compression
+
+      switch (this.compressionType) {
+        case Zlib.RawDeflate.CompressionType.NONE:
+          // each 65535-Byte (length header: 16-bit)
+          for (position = 0, length = input.length; position < length;) {
+            blockArray = input.subarray(position, position + 0xffff);
+            position += blockArray.length;
+            this.makeNocompressBlock(blockArray, position === length);
+          }
+
+          break;
+
+        case Zlib.RawDeflate.CompressionType.FIXED:
+          this.output = this.makeFixedHuffmanBlock(input, true);
+          this.op = this.output.length;
+          break;
+
+        case Zlib.RawDeflate.CompressionType.DYNAMIC:
+          this.output = this.makeDynamicHuffmanBlock(input, true);
+          this.op = this.output.length;
+          break;
+
+        default:
+          throw 'invalid compression type';
+      }
+
+      return this.output;
+    };
+    /**
+     * 非圧縮ブロックの作成
+     * @param {!(Array.<number>|Uint8Array)} blockArray ブロックデータ byte array.
+     * @param {!boolean} isFinalBlock 最後のブロックならばtrue.
+     * @return {!(Array.<number>|Uint8Array)} 非圧縮ブロック byte array.
+     */
+
+
+    Zlib.RawDeflate.prototype.makeNocompressBlock = function (blockArray, isFinalBlock) {
+      /** @type {number} */
+      var bfinal;
+      /** @type {Zlib.RawDeflate.CompressionType} */
+
+      var btype;
+      /** @type {number} */
+
+      var len;
+      /** @type {number} */
+
+      var nlen;
+      var output = this.output;
+      var op = this.op; // expand buffer
+
+      {
+        output = new Uint8Array(this.output.buffer);
+
+        while (output.length <= op + blockArray.length + 5) {
+          output = new Uint8Array(output.length << 1);
+        }
+
+        output.set(this.output);
+      } // header
+
+      bfinal = isFinalBlock ? 1 : 0;
+      btype = Zlib.RawDeflate.CompressionType.NONE;
+      output[op++] = bfinal | btype << 1; // length
+
+      len = blockArray.length;
+      nlen = ~len + 0x10000 & 0xffff;
+      output[op++] = len & 0xff;
+      output[op++] = len >>> 8 & 0xff;
+      output[op++] = nlen & 0xff;
+      output[op++] = nlen >>> 8 & 0xff; // copy buffer
+
+      {
+        output.set(blockArray, op);
+        op += blockArray.length;
+        output = output.subarray(0, op);
+      }
+      this.op = op;
+      this.output = output;
+      return output;
+    };
+    /**
+     * 固定ハフマンブロックの作成
+     * @param {!(Array.<number>|Uint8Array)} blockArray ブロックデータ byte array.
+     * @param {!boolean} isFinalBlock 最後のブロックならばtrue.
+     * @return {!(Array.<number>|Uint8Array)} 固定ハフマン符号化ブロック byte array.
+     */
+
+
+    Zlib.RawDeflate.prototype.makeFixedHuffmanBlock = function (blockArray, isFinalBlock) {
+      /** @type {Zlib.BitStream} */
+      var stream = new Zlib.BitStream(new Uint8Array(this.output.buffer), this.op);
+      /** @type {number} */
+
+      var bfinal;
+      /** @type {Zlib.RawDeflate.CompressionType} */
+
+      var btype;
+      /** @type {!(Array.<number>|Uint16Array)} */
+
+      var data; // header
+
+      bfinal = isFinalBlock ? 1 : 0;
+      btype = Zlib.RawDeflate.CompressionType.FIXED;
+      stream.writeBits(bfinal, 1, true);
+      stream.writeBits(btype, 2, true);
+      data = this.lz77(blockArray);
+      this.fixedHuffman(data, stream);
+      return stream.finish();
+    };
+    /**
+     * 動的ハフマンブロックの作成
+     * @param {!(Array.<number>|Uint8Array)} blockArray ブロックデータ byte array.
+     * @param {!boolean} isFinalBlock 最後のブロックならばtrue.
+     * @return {!(Array.<number>|Uint8Array)} 動的ハフマン符号ブロック byte array.
+     */
+
+
+    Zlib.RawDeflate.prototype.makeDynamicHuffmanBlock = function (blockArray, isFinalBlock) {
+      /** @type {Zlib.BitStream} */
+      var stream = new Zlib.BitStream(new Uint8Array(this.output.buffer), this.op);
+      /** @type {number} */
+
+      var bfinal;
+      /** @type {Zlib.RawDeflate.CompressionType} */
+
+      var btype;
+      /** @type {!(Array.<number>|Uint16Array)} */
+
+      var data;
+      /** @type {number} */
+
+      var hlit;
+      /** @type {number} */
+
+      var hdist;
+      /** @type {number} */
+
+      var hclen;
+      /** @const @type {Array.<number>} */
+
+      var hclenOrder = [16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15];
+      /** @type {!(Array.<number>|Uint8Array)} */
+
+      var litLenLengths;
+      /** @type {!(Array.<number>|Uint16Array)} */
+
+      var litLenCodes;
+      /** @type {!(Array.<number>|Uint8Array)} */
+
+      var distLengths;
+      /** @type {!(Array.<number>|Uint16Array)} */
+
+      var distCodes;
+      /** @type {{
+       *   codes: !(Array.<number>|Uint32Array),
+       *   freqs: !(Array.<number>|Uint8Array)
+       * }} */
+
+      var treeSymbols;
+      /** @type {!(Array.<number>|Uint8Array)} */
+
+      var treeLengths;
+      /** @type {Array} */
+
+      var transLengths = new Array(19);
+      /** @type {!(Array.<number>|Uint16Array)} */
+
+      var treeCodes;
+      /** @type {number} */
+
+      var code;
+      /** @type {number} */
+
+      var bitlen;
+      /** @type {number} */
+
+      var i;
+      /** @type {number} */
+
+      var il; // header
+
+      bfinal = isFinalBlock ? 1 : 0;
+      btype = Zlib.RawDeflate.CompressionType.DYNAMIC;
+      stream.writeBits(bfinal, 1, true);
+      stream.writeBits(btype, 2, true);
+      data = this.lz77(blockArray); // リテラル・長さ, 距離のハフマン符号と符号長の算出
+
+      litLenLengths = this.getLengths_(this.freqsLitLen, 15);
+      litLenCodes = this.getCodesFromLengths_(litLenLengths);
+      distLengths = this.getLengths_(this.freqsDist, 7);
+      distCodes = this.getCodesFromLengths_(distLengths); // HLIT, HDIST の決定
+
+      for (hlit = 286; hlit > 257 && litLenLengths[hlit - 1] === 0; hlit--) {}
+
+      for (hdist = 30; hdist > 1 && distLengths[hdist - 1] === 0; hdist--) {} // HCLEN
+
+
+      treeSymbols = this.getTreeSymbols_(hlit, litLenLengths, hdist, distLengths);
+      treeLengths = this.getLengths_(treeSymbols.freqs, 7);
+
+      for (i = 0; i < 19; i++) {
+        transLengths[i] = treeLengths[hclenOrder[i]];
+      }
+
+      for (hclen = 19; hclen > 4 && transLengths[hclen - 1] === 0; hclen--) {}
+
+      treeCodes = this.getCodesFromLengths_(treeLengths); // 出力
+
+      stream.writeBits(hlit - 257, 5, true);
+      stream.writeBits(hdist - 1, 5, true);
+      stream.writeBits(hclen - 4, 4, true);
+
+      for (i = 0; i < hclen; i++) {
+        stream.writeBits(transLengths[i], 3, true);
+      } // ツリーの出力
+
+
+      for (i = 0, il = treeSymbols.codes.length; i < il; i++) {
+        code = treeSymbols.codes[i];
+        stream.writeBits(treeCodes[code], treeLengths[code], true); // extra bits
+
+        if (code >= 16) {
+          i++;
+
+          switch (code) {
+            case 16:
+              bitlen = 2;
+              break;
+
+            case 17:
+              bitlen = 3;
+              break;
+
+            case 18:
+              bitlen = 7;
+              break;
+
+            default:
+              throw 'invalid code: ' + code;
+          }
+
+          stream.writeBits(treeSymbols.codes[i], bitlen, true);
+        }
+      }
+
+      this.dynamicHuffman(data, [litLenCodes, litLenLengths], [distCodes, distLengths], stream);
+      return stream.finish();
+    };
+    /**
+     * 動的ハフマン符号化(カスタムハフマンテーブル)
+     * @param {!(Array.<number>|Uint16Array)} dataArray LZ77 符号化済み byte array.
+     * @param {!Zlib.BitStream} stream 書き込み用ビットストリーム.
+     * @return {!Zlib.BitStream} ハフマン符号化済みビットストリームオブジェクト.
+     */
+
+
+    Zlib.RawDeflate.prototype.dynamicHuffman = function (dataArray, litLen, dist, stream) {
+      /** @type {number} */
+      var index;
+      /** @type {number} */
+
+      var length;
+      /** @type {number} */
+
+      var literal;
+      /** @type {number} */
+
+      var code;
+      /** @type {number} */
+
+      var litLenCodes;
+      /** @type {number} */
+
+      var litLenLengths;
+      /** @type {number} */
+
+      var distCodes;
+      /** @type {number} */
+
+      var distLengths;
+      litLenCodes = litLen[0];
+      litLenLengths = litLen[1];
+      distCodes = dist[0];
+      distLengths = dist[1]; // 符号を BitStream に書き込んでいく
+
+      for (index = 0, length = dataArray.length; index < length; ++index) {
+        literal = dataArray[index]; // literal or length
+
+        stream.writeBits(litLenCodes[literal], litLenLengths[literal], true); // 長さ・距離符号
+
+        if (literal > 256) {
+          // length extra
+          stream.writeBits(dataArray[++index], dataArray[++index], true); // distance
+
+          code = dataArray[++index];
+          stream.writeBits(distCodes[code], distLengths[code], true); // distance extra
+
+          stream.writeBits(dataArray[++index], dataArray[++index], true); // 終端
+        } else if (literal === 256) {
+          break;
+        }
+      }
+
+      return stream;
+    };
+    /**
+     * 固定ハフマン符号化
+     * @param {!(Array.<number>|Uint16Array)} dataArray LZ77 符号化済み byte array.
+     * @param {!Zlib.BitStream} stream 書き込み用ビットストリーム.
+     * @return {!Zlib.BitStream} ハフマン符号化済みビットストリームオブジェクト.
+     */
+
+
+    Zlib.RawDeflate.prototype.fixedHuffman = function (dataArray, stream) {
+      /** @type {number} */
+      var index;
+      /** @type {number} */
+
+      var length;
+      /** @type {number} */
+
+      var literal; // 符号を BitStream に書き込んでいく
+
+      for (index = 0, length = dataArray.length; index < length; index++) {
+        literal = dataArray[index]; // 符号の書き込み
+
+        Zlib.BitStream.prototype.writeBits.apply(stream, Zlib.RawDeflate.FixedHuffmanTable[literal]); // 長さ・距離符号
+
+        if (literal > 0x100) {
+          // length extra
+          stream.writeBits(dataArray[++index], dataArray[++index], true); // distance
+
+          stream.writeBits(dataArray[++index], 5); // distance extra
+
+          stream.writeBits(dataArray[++index], dataArray[++index], true); // 終端
+        } else if (literal === 0x100) {
+          break;
+        }
+      }
+
+      return stream;
+    };
+    /**
+     * ãƒžãƒƒãƒæƒ…å ±
+     * @param {!number} length マッチした長さ.
+     * @param {!number} backwardDistance マッチ位置との距離.
+     * @constructor
+     */
+
+
+    Zlib.RawDeflate.Lz77Match = function (length, backwardDistance) {
+      /** @type {number} match length. */
+      this.length = length;
+      /** @type {number} backward distance. */
+
+      this.backwardDistance = backwardDistance;
+    };
+    /**
+     * 長さ符号テーブル.
+     * [コード, 拡張ビット, 拡張ビット長] の配列となっている.
+     * @const
+     * @type {!(Array.<number>|Uint32Array)}
+     */
+
+
+    Zlib.RawDeflate.Lz77Match.LengthCodeTable = function (table) {
+      return new Uint32Array(table);
+    }(function () {
+      /** @type {!Array} */
+      var table = [];
+      /** @type {number} */
+
+      var i;
+      /** @type {!Array.<number>} */
+
+      var c;
+
+      for (i = 3; i <= 258; i++) {
+        c = code(i);
+        table[i] = c[2] << 24 | c[1] << 16 | c[0];
+      }
+      /**
+       * @param {number} length lz77 length.
+       * @return {!Array.<number>} lz77 codes.
+       */
+
+
+      function code(length) {
+        switch (true) {
+          case length === 3:
+            return [257, length - 3, 0];
+
+          case length === 4:
+            return [258, length - 4, 0];
+
+          case length === 5:
+            return [259, length - 5, 0];
+
+          case length === 6:
+            return [260, length - 6, 0];
+
+          case length === 7:
+            return [261, length - 7, 0];
+
+          case length === 8:
+            return [262, length - 8, 0];
+
+          case length === 9:
+            return [263, length - 9, 0];
+
+          case length === 10:
+            return [264, length - 10, 0];
+
+          case length <= 12:
+            return [265, length - 11, 1];
+
+          case length <= 14:
+            return [266, length - 13, 1];
+
+          case length <= 16:
+            return [267, length - 15, 1];
+
+          case length <= 18:
+            return [268, length - 17, 1];
+
+          case length <= 22:
+            return [269, length - 19, 2];
+
+          case length <= 26:
+            return [270, length - 23, 2];
+
+          case length <= 30:
+            return [271, length - 27, 2];
+
+          case length <= 34:
+            return [272, length - 31, 2];
+
+          case length <= 42:
+            return [273, length - 35, 3];
+
+          case length <= 50:
+            return [274, length - 43, 3];
+
+          case length <= 58:
+            return [275, length - 51, 3];
+
+          case length <= 66:
+            return [276, length - 59, 3];
+
+          case length <= 82:
+            return [277, length - 67, 4];
+
+          case length <= 98:
+            return [278, length - 83, 4];
+
+          case length <= 114:
+            return [279, length - 99, 4];
+
+          case length <= 130:
+            return [280, length - 115, 4];
+
+          case length <= 162:
+            return [281, length - 131, 5];
+
+          case length <= 194:
+            return [282, length - 163, 5];
+
+          case length <= 226:
+            return [283, length - 195, 5];
+
+          case length <= 257:
+            return [284, length - 227, 5];
+
+          case length === 258:
+            return [285, length - 258, 0];
+
+          default:
+            throw 'invalid length: ' + length;
+        }
+      }
+
+      return table;
+    }());
+    /**
+     * 距離符号テーブル
+     * @param {!number} dist 距離.
+     * @return {!Array.<number>} コード、拡張ビット、拡張ビット長の配列.
+     * @private
+     */
+
+
+    Zlib.RawDeflate.Lz77Match.prototype.getDistanceCode_ = function (dist) {
+      /** @type {!Array.<number>} distance code table. */
+      var r;
+
+      switch (true) {
+        case dist === 1:
+          r = [0, dist - 1, 0];
+          break;
+
+        case dist === 2:
+          r = [1, dist - 2, 0];
+          break;
+
+        case dist === 3:
+          r = [2, dist - 3, 0];
+          break;
+
+        case dist === 4:
+          r = [3, dist - 4, 0];
+          break;
+
+        case dist <= 6:
+          r = [4, dist - 5, 1];
+          break;
+
+        case dist <= 8:
+          r = [5, dist - 7, 1];
+          break;
+
+        case dist <= 12:
+          r = [6, dist - 9, 2];
+          break;
+
+        case dist <= 16:
+          r = [7, dist - 13, 2];
+          break;
+
+        case dist <= 24:
+          r = [8, dist - 17, 3];
+          break;
+
+        case dist <= 32:
+          r = [9, dist - 25, 3];
+          break;
+
+        case dist <= 48:
+          r = [10, dist - 33, 4];
+          break;
+
+        case dist <= 64:
+          r = [11, dist - 49, 4];
+          break;
+
+        case dist <= 96:
+          r = [12, dist - 65, 5];
+          break;
+
+        case dist <= 128:
+          r = [13, dist - 97, 5];
+          break;
+
+        case dist <= 192:
+          r = [14, dist - 129, 6];
+          break;
+
+        case dist <= 256:
+          r = [15, dist - 193, 6];
+          break;
+
+        case dist <= 384:
+          r = [16, dist - 257, 7];
+          break;
+
+        case dist <= 512:
+          r = [17, dist - 385, 7];
+          break;
+
+        case dist <= 768:
+          r = [18, dist - 513, 8];
+          break;
+
+        case dist <= 1024:
+          r = [19, dist - 769, 8];
+          break;
+
+        case dist <= 1536:
+          r = [20, dist - 1025, 9];
+          break;
+
+        case dist <= 2048:
+          r = [21, dist - 1537, 9];
+          break;
+
+        case dist <= 3072:
+          r = [22, dist - 2049, 10];
+          break;
+
+        case dist <= 4096:
+          r = [23, dist - 3073, 10];
+          break;
+
+        case dist <= 6144:
+          r = [24, dist - 4097, 11];
+          break;
+
+        case dist <= 8192:
+          r = [25, dist - 6145, 11];
+          break;
+
+        case dist <= 12288:
+          r = [26, dist - 8193, 12];
+          break;
+
+        case dist <= 16384:
+          r = [27, dist - 12289, 12];
+          break;
+
+        case dist <= 24576:
+          r = [28, dist - 16385, 13];
+          break;
+
+        case dist <= 32768:
+          r = [29, dist - 24577, 13];
+          break;
+
+        default:
+          throw 'invalid distance';
+      }
+
+      return r;
+    };
+    /**
+     * ãƒžãƒƒãƒæƒ…å ±ã‚’ LZ77 符号化配列で返す.
+     * なお、ここでは以下の内部仕様で符号化している
+     * [ CODE, EXTRA-BIT-LEN, EXTRA, CODE, EXTRA-BIT-LEN, EXTRA ]
+     * @return {!Array.<number>} LZ77 符号化 byte array.
+     */
+
+
+    Zlib.RawDeflate.Lz77Match.prototype.toLz77Array = function () {
+      /** @type {number} */
+      var length = this.length;
+      /** @type {number} */
+
+      var dist = this.backwardDistance;
+      /** @type {Array} */
+
+      var codeArray = [];
+      /** @type {number} */
+
+      var pos = 0;
+      /** @type {!Array.<number>} */
+
+      var code; // length
+
+      code = Zlib.RawDeflate.Lz77Match.LengthCodeTable[length];
+      codeArray[pos++] = code & 0xffff;
+      codeArray[pos++] = code >> 16 & 0xff;
+      codeArray[pos++] = code >> 24; // distance
+
+      code = this.getDistanceCode_(dist);
+      codeArray[pos++] = code[0];
+      codeArray[pos++] = code[1];
+      codeArray[pos++] = code[2];
+      return codeArray;
+    };
+    /**
+     * LZ77 実装
+     * @param {!(Array.<number>|Uint8Array)} dataArray LZ77 符号化するバイト配列.
+     * @return {!(Array.<number>|Uint16Array)} LZ77 符号化した配列.
+     */
+
+
+    Zlib.RawDeflate.prototype.lz77 = function (dataArray) {
+      /** @type {number} input position */
+      var position;
+      /** @type {number} input length */
+
+      var length;
+      /** @type {number} loop counter */
+
+      var i;
+      /** @type {number} loop limiter */
+
+      var il;
+      /** @type {number} chained-hash-table key */
+
+      var matchKey;
+      /** @type {Object.<number, Array.<number>>} chained-hash-table */
+
+      var table = {};
+      /** @const @type {number} */
+
+      var windowSize = Zlib.RawDeflate.WindowSize;
+      /** @type {Array.<number>} match list */
+
+      var matchList;
+      /** @type {Zlib.RawDeflate.Lz77Match} longest match */
+
+      var longestMatch;
+      /** @type {Zlib.RawDeflate.Lz77Match} previous longest match */
+
+      var prevMatch;
+      /** @type {!(Array.<number>|Uint16Array)} lz77 buffer */
+
+      var lz77buf = new Uint16Array(dataArray.length * 2);
+      /** @type {number} lz77 output buffer pointer */
+
+      var pos = 0;
+      /** @type {number} lz77 skip length */
+
+      var skipLength = 0;
+      /** @type {!(Array.<number>|Uint32Array)} */
+
+      var freqsLitLen = new Uint32Array(286);
+      /** @type {!(Array.<number>|Uint32Array)} */
+
+      var freqsDist = new Uint32Array(30);
+      /** @type {number} */
+
+      var lazy = this.lazy;
+      /** @type {*} temporary variable */
+
+      var tmp;
+      freqsLitLen[256] = 1; // EOB の最低出現回数は 1
+
+      /**
+       * マッチデータの書き込み
+       * @param {Zlib.RawDeflate.Lz77Match} match LZ77 Match data.
+       * @param {!number} offset スキップ開始位置(相対指定).
+       * @private
+       */
+
+      function writeMatch(match, offset) {
+        /** @type {Array.<number>} */
+        var lz77Array = match.toLz77Array();
+        /** @type {number} */
+
+        var i;
+        /** @type {number} */
+
+        var il;
+
+        for (i = 0, il = lz77Array.length; i < il; ++i) {
+          lz77buf[pos++] = lz77Array[i];
+        }
+
+        freqsLitLen[lz77Array[0]]++;
+        freqsDist[lz77Array[3]]++;
+        skipLength = match.length + offset - 1;
+        prevMatch = null;
+      } // LZ77 符号化
+
+
+      for (position = 0, length = dataArray.length; position < length; ++position) {
+        // ハッシュキーの作成
+        for (matchKey = 0, i = 0, il = Zlib.RawDeflate.Lz77MinLength; i < il; ++i) {
+          if (position + i === length) {
+            break;
+          }
+
+          matchKey = matchKey << 8 | dataArray[position + i];
+        } // テーブルが未定義だったら作成する
+
+
+        if (table[matchKey] === void 0) {
+          table[matchKey] = [];
+        }
+
+        matchList = table[matchKey]; // skip
+
+        if (skipLength-- > 0) {
+          matchList.push(position);
+          continue;
+        } // マッチテーブルの更新 (最大戻り距離を超えているものを削除する)
+
+
+        while (matchList.length > 0 && position - matchList[0] > windowSize) {
+          matchList.shift();
+        } // ãƒ‡ãƒ¼ã‚¿æœ«å°¾ã§ãƒžãƒƒãƒã—ã‚ˆã†ãŒãªã„å ´åˆã¯ãã®ã¾ã¾æµã—ã“ã‚€
+
+
+        if (position + Zlib.RawDeflate.Lz77MinLength >= length) {
+          if (prevMatch) {
+            writeMatch(prevMatch, -1);
+          }
+
+          for (i = 0, il = length - position; i < il; ++i) {
+            tmp = dataArray[position + i];
+            lz77buf[pos++] = tmp;
+            ++freqsLitLen[tmp];
+          }
+
+          break;
+        } // マッチ候補から最長のものを探す
+
+
+        if (matchList.length > 0) {
+          longestMatch = this.searchLongestMatch_(dataArray, position, matchList);
+
+          if (prevMatch) {
+            // 現在のマッチの方が前回のマッチよりも長い
+            if (prevMatch.length < longestMatch.length) {
+              // write previous literal
+              tmp = dataArray[position - 1];
+              lz77buf[pos++] = tmp;
+              ++freqsLitLen[tmp]; // write current match
+
+              writeMatch(longestMatch, 0);
+            } else {
+              // write previous match
+              writeMatch(prevMatch, -1);
+            }
+          } else if (longestMatch.length < lazy) {
+            prevMatch = longestMatch;
+          } else {
+            writeMatch(longestMatch, 0);
+          } // 前回マッチしていて今回マッチがなかったら前回のを採用
+
+        } else if (prevMatch) {
+          writeMatch(prevMatch, -1);
+        } else {
+          tmp = dataArray[position];
+          lz77buf[pos++] = tmp;
+          ++freqsLitLen[tmp];
+        }
+
+        matchList.push(position); // マッチテーブルに現在の位置を保存
+      } // 終端処理
+
+
+      lz77buf[pos++] = 256;
+      freqsLitLen[256]++;
+      this.freqsLitLen = freqsLitLen;
+      this.freqsDist = freqsDist;
+      return lz77buf.subarray(0, pos);
+    };
+    /**
+     * マッチした候補の中から最長一致を探す
+     * @param {!Object} data plain data byte array.
+     * @param {!number} position plain data byte array position.
+     * @param {!Array.<number>} matchList 候補となる位置の配列.
+     * @return {!Zlib.RawDeflate.Lz77Match} 最長かつ最短距離のマッチオブジェクト.
+     * @private
+     */
+
+
+    Zlib.RawDeflate.prototype.searchLongestMatch_ = function (data, position, matchList) {
+      var match,
+          currentMatch,
+          matchMax = 0,
+          matchLength,
+          i,
+          j,
+          l,
+          dl = data.length; // 候補を後ろから 1 つずつ絞り込んでゆく
+
+      permatch: for (i = 0, l = matchList.length; i < l; i++) {
+        match = matchList[l - i - 1];
+        matchLength = Zlib.RawDeflate.Lz77MinLength; // 前回までの最長一致を末尾から一致検索する
+
+        if (matchMax > Zlib.RawDeflate.Lz77MinLength) {
+          for (j = matchMax; j > Zlib.RawDeflate.Lz77MinLength; j--) {
+            if (data[match + j - 1] !== data[position + j - 1]) {
+              continue permatch;
+            }
+          }
+
+          matchLength = matchMax;
+        } // 最長一致探索
+
+
+        while (matchLength < Zlib.RawDeflate.Lz77MaxLength && position + matchLength < dl && data[match + matchLength] === data[position + matchLength]) {
+          ++matchLength;
+        } // ãƒžãƒƒãƒé•·ãŒåŒã˜å ´åˆã¯å¾Œæ–¹ã‚’å„ªå…ˆ
+
+
+        if (matchLength > matchMax) {
+          currentMatch = match;
+          matchMax = matchLength;
+        } // 最長が確定したら後の処理は省略
+
+
+        if (matchLength === Zlib.RawDeflate.Lz77MaxLength) {
+          break;
+        }
+      }
+
+      return new Zlib.RawDeflate.Lz77Match(matchMax, position - currentMatch);
+    };
+    /**
+     * Tree-Transmit Symbols の算出
+     * reference: PuTTY Deflate implementation
+     * @param {number} hlit HLIT.
+     * @param {!(Array.<number>|Uint8Array)} litlenLengths リテラルと長さ符号の符号長配列.
+     * @param {number} hdist HDIST.
+     * @param {!(Array.<number>|Uint8Array)} distLengths 距離符号の符号長配列.
+     * @return {{
+     *   codes: !(Array.<number>|Uint32Array),
+     *   freqs: !(Array.<number>|Uint8Array)
+     * }} Tree-Transmit Symbols.
+     */
+
+
+    Zlib.RawDeflate.prototype.getTreeSymbols_ = function (hlit, litlenLengths, hdist, distLengths) {
+      var src = new Uint32Array(hlit + hdist),
+          i,
+          j,
+          runLength,
+          l,
+          result = new Uint32Array(286 + 30),
+          nResult,
+          rpt,
+          freqs = new Uint8Array(19);
+      j = 0;
+
+      for (i = 0; i < hlit; i++) {
+        src[j++] = litlenLengths[i];
+      }
+
+      for (i = 0; i < hdist; i++) {
+        src[j++] = distLengths[i];
+      } // 符号化
+
+
+      nResult = 0;
+
+      for (i = 0, l = src.length; i < l; i += j) {
+        // Run Length Encoding
+        for (j = 1; i + j < l && src[i + j] === src[i]; ++j) {}
+
+        runLength = j;
+
+        if (src[i] === 0) {
+          // 0 の繰り返しが 3 回未満ならばそのまま
+          if (runLength < 3) {
+            while (runLength-- > 0) {
+              result[nResult++] = 0;
+              freqs[0]++;
+            }
+          } else {
+            while (runLength > 0) {
+              // 繰り返しは最大 138 までなので切り詰める
+              rpt = runLength < 138 ? runLength : 138;
+
+              if (rpt > runLength - 3 && rpt < runLength) {
+                rpt = runLength - 3;
+              } // 3-10 回 -> 17
+
+
+              if (rpt <= 10) {
+                result[nResult++] = 17;
+                result[nResult++] = rpt - 3;
+                freqs[17]++; // 11-138 回 -> 18
+              } else {
+                result[nResult++] = 18;
+                result[nResult++] = rpt - 11;
+                freqs[18]++;
+              }
+
+              runLength -= rpt;
+            }
+          }
+        } else {
+          result[nResult++] = src[i];
+          freqs[src[i]]++;
+          runLength--; // 繰り返し回数が3回未満ならばランレングス符号は要らない
+
+          if (runLength < 3) {
+            while (runLength-- > 0) {
+              result[nResult++] = src[i];
+              freqs[src[i]]++;
+            } // 3 回以上ならばランレングス符号化
+
+          } else {
+            while (runLength > 0) {
+              // runLengthを 3-6 で分割
+              rpt = runLength < 6 ? runLength : 6;
+
+              if (rpt > runLength - 3 && rpt < runLength) {
+                rpt = runLength - 3;
+              }
+
+              result[nResult++] = 16;
+              result[nResult++] = rpt - 3;
+              freqs[16]++;
+              runLength -= rpt;
+            }
+          }
+        }
+      }
+
+      return {
+        codes: result.subarray(0, nResult),
+        freqs: freqs
+      };
+    };
+    /**
+     * ハフマン符号の長さを取得する
+     * @param {!(Array.<number>|Uint8Array|Uint32Array)} freqs 出現カウント.
+     * @param {number} limit 符号長の制限.
+     * @return {!(Array.<number>|Uint8Array)} 符号長配列.
+     * @private
+     */
+
+
+    Zlib.RawDeflate.prototype.getLengths_ = function (freqs, limit) {
+      /** @type {number} */
+      var nSymbols = freqs.length;
+      /** @type {Zlib.Heap} */
+
+      var heap = new Zlib.Heap(2 * Zlib.RawDeflate.HUFMAX);
+      /** @type {!(Array.<number>|Uint8Array)} */
+
+      var length = new Uint8Array(nSymbols);
+      /** @type {Array} */
+
+      var nodes;
+      /** @type {!(Array.<number>|Uint32Array)} */
+
+      var values;
+      /** @type {!(Array.<number>|Uint8Array)} */
+
+      var codeLength;
+      /** @type {number} */
+
+      var i;
+      /** @type {number} */
+
+      var il; // ヒープの構築
+
+      for (i = 0; i < nSymbols; ++i) {
+        if (freqs[i] > 0) {
+          heap.push(i, freqs[i]);
+        }
+      }
+
+      nodes = new Array(heap.length / 2);
+      values = new Uint32Array(heap.length / 2); // 非 0 ã®è¦ç´ ãŒä¸€ã¤ã ã‘ã ã£ãŸå ´åˆã¯ã€ãã®ã‚·ãƒ³ãƒœãƒ«ã«ç¬¦å·é•· 1 を割り当てて終了
+
+      if (nodes.length === 1) {
+        length[heap.pop().index] = 1;
+        return length;
+      } // Reverse Package Merge Algorithm による Canonical Huffman Code の符号長決定
+
+
+      for (i = 0, il = heap.length / 2; i < il; ++i) {
+        nodes[i] = heap.pop();
+        values[i] = nodes[i].value;
+      }
+
+      codeLength = this.reversePackageMerge_(values, values.length, limit);
+
+      for (i = 0, il = nodes.length; i < il; ++i) {
+        length[nodes[i].index] = codeLength[i];
+      }
+
+      return length;
+    };
+    /**
+     * Reverse Package Merge Algorithm.
+     * @param {!(Array.<number>|Uint32Array)} freqs sorted probability.
+     * @param {number} symbols number of symbols.
+     * @param {number} limit code length limit.
+     * @return {!(Array.<number>|Uint8Array)} code lengths.
+     */
+
+
+    Zlib.RawDeflate.prototype.reversePackageMerge_ = function (freqs, symbols, limit) {
+      /** @type {!(Array.<number>|Uint16Array)} */
+      var minimumCost = new Uint16Array(limit);
+      /** @type {!(Array.<number>|Uint8Array)} */
+
+      var flag = new Uint8Array(limit);
+      /** @type {!(Array.<number>|Uint8Array)} */
+
+      var codeLength = new Uint8Array(symbols);
+      /** @type {Array} */
+
+      var value = new Array(limit);
+      /** @type {Array} */
+
+      var type = new Array(limit);
+      /** @type {Array.<number>} */
+
+      var currentPosition = new Array(limit);
+      /** @type {number} */
+
+      var excess = (1 << limit) - symbols;
+      /** @type {number} */
+
+      var half = 1 << limit - 1;
+      /** @type {number} */
+
+      var i;
+      /** @type {number} */
+
+      var j;
+      /** @type {number} */
+
+      var t;
+      /** @type {number} */
+
+      var weight;
+      /** @type {number} */
+
+      var next;
+      /**
+       * @param {number} j
+       */
+
+      function takePackage(j) {
+        /** @type {number} */
+        var x = type[j][currentPosition[j]];
+
+        if (x === symbols) {
+          takePackage(j + 1);
+          takePackage(j + 1);
+        } else {
+          --codeLength[x];
+        }
+
+        ++currentPosition[j];
+      }
+
+      minimumCost[limit - 1] = symbols;
+
+      for (j = 0; j < limit; ++j) {
+        if (excess < half) {
+          flag[j] = 0;
+        } else {
+          flag[j] = 1;
+          excess -= half;
+        }
+
+        excess <<= 1;
+        minimumCost[limit - 2 - j] = (minimumCost[limit - 1 - j] / 2 | 0) + symbols;
+      }
+
+      minimumCost[0] = flag[0];
+      value[0] = new Array(minimumCost[0]);
+      type[0] = new Array(minimumCost[0]);
+
+      for (j = 1; j < limit; ++j) {
+        if (minimumCost[j] > 2 * minimumCost[j - 1] + flag[j]) {
+          minimumCost[j] = 2 * minimumCost[j - 1] + flag[j];
+        }
+
+        value[j] = new Array(minimumCost[j]);
+        type[j] = new Array(minimumCost[j]);
+      }
+
+      for (i = 0; i < symbols; ++i) {
+        codeLength[i] = limit;
+      }
+
+      for (t = 0; t < minimumCost[limit - 1]; ++t) {
+        value[limit - 1][t] = freqs[t];
+        type[limit - 1][t] = t;
+      }
+
+      for (i = 0; i < limit; ++i) {
+        currentPosition[i] = 0;
+      }
+
+      if (flag[limit - 1] === 1) {
+        --codeLength[0];
+        ++currentPosition[limit - 1];
+      }
+
+      for (j = limit - 2; j >= 0; --j) {
+        i = 0;
+        weight = 0;
+        next = currentPosition[j + 1];
+
+        for (t = 0; t < minimumCost[j]; t++) {
+          weight = value[j + 1][next] + value[j + 1][next + 1];
+
+          if (weight > freqs[i]) {
+            value[j][t] = weight;
+            type[j][t] = symbols;
+            next += 2;
+          } else {
+            value[j][t] = freqs[i];
+            type[j][t] = i;
+            ++i;
+          }
+        }
+
+        currentPosition[j] = 0;
+
+        if (flag[j] === 1) {
+          takePackage(j);
+        }
+      }
+
+      return codeLength;
+    };
+    /**
+     * 符号長配列からハフマン符号を取得する
+     * reference: PuTTY Deflate implementation
+     * @param {!(Array.<number>|Uint8Array)} lengths 符号長配列.
+     * @return {!(Array.<number>|Uint16Array)} ハフマン符号配列.
+     * @private
+     */
+
+
+    Zlib.RawDeflate.prototype.getCodesFromLengths_ = function (lengths) {
+      var codes = new Uint16Array(lengths.length),
+          count = [],
+          startCode = [],
+          code = 0,
+          i,
+          il,
+          j,
+          m; // Count the codes of each length.
+
+      for (i = 0, il = lengths.length; i < il; i++) {
+        count[lengths[i]] = (count[lengths[i]] | 0) + 1;
+      } // Determine the starting code for each length block.
+
+
+      for (i = 1, il = Zlib.RawDeflate.MaxCodeLength; i <= il; i++) {
+        startCode[i] = code;
+        code += count[i] | 0;
+        code <<= 1;
+      } // Determine the code for each symbol. Mirrored, of course.
+
+
+      for (i = 0, il = lengths.length; i < il; i++) {
+        code = startCode[lengths[i]];
+        startCode[lengths[i]] += 1;
+        codes[i] = 0;
+
+        for (j = 0, m = lengths[i]; j < m; j++) {
+          codes[i] = codes[i] << 1 | code & 1;
+          code >>>= 1;
+        }
+      }
+
+      return codes;
+    };
+    /**
+     * @param {!(Array.<number>|Uint8Array)} input input buffer.
+     * @param {Object=} opt_params options.
+     * @constructor
+     */
+
+
+    Zlib.Unzip = function (input, opt_params) {
+      opt_params = opt_params || {};
+      /** @type {!(Array.<number>|Uint8Array)} */
+
+      this.input = input instanceof Array ? new Uint8Array(input) : input;
+      /** @type {number} */
+
+      this.ip = 0;
+      /** @type {number} */
+
+      this.eocdrOffset;
+      /** @type {number} */
+
+      this.numberOfThisDisk;
+      /** @type {number} */
+
+      this.startDisk;
+      /** @type {number} */
+
+      this.totalEntriesThisDisk;
+      /** @type {number} */
+
+      this.totalEntries;
+      /** @type {number} */
+
+      this.centralDirectorySize;
+      /** @type {number} */
+
+      this.centralDirectoryOffset;
+      /** @type {number} */
+
+      this.commentLength;
+      /** @type {(Array.<number>|Uint8Array)} */
+
+      this.comment;
+      /** @type {Array.<Zlib.Unzip.FileHeader>} */
+
+      this.fileHeaderList;
+      /** @type {Object.<string, number>} */
+
+      this.filenameToIndex;
+      /** @type {boolean} */
+
+      this.verify = opt_params['verify'] || false;
+      /** @type {(Array.<number>|Uint8Array)} */
+
+      this.password = opt_params['password'];
+    };
+
+    Zlib.Unzip.CompressionMethod = Zlib.Zip.CompressionMethod;
+    /**
+     * @type {Array.<number>}
+     * @const
+     */
+
+    Zlib.Unzip.FileHeaderSignature = Zlib.Zip.FileHeaderSignature;
+    /**
+     * @type {Array.<number>}
+     * @const
+     */
+
+    Zlib.Unzip.LocalFileHeaderSignature = Zlib.Zip.LocalFileHeaderSignature;
+    /**
+     * @type {Array.<number>}
+     * @const
+     */
+
+    Zlib.Unzip.CentralDirectorySignature = Zlib.Zip.CentralDirectorySignature;
+    /**
+     * @param {!(Array.<number>|Uint8Array)} input input buffer.
+     * @param {number} ip input position.
+     * @constructor
+     */
+
+    Zlib.Unzip.FileHeader = function (input, ip) {
+      /** @type {!(Array.<number>|Uint8Array)} */
+      this.input = input;
+      /** @type {number} */
+
+      this.offset = ip;
+      /** @type {number} */
+
+      this.length;
+      /** @type {number} */
+
+      this.version;
+      /** @type {number} */
+
+      this.os;
+      /** @type {number} */
+
+      this.needVersion;
+      /** @type {number} */
+
+      this.flags;
+      /** @type {number} */
+
+      this.compression;
+      /** @type {number} */
+
+      this.time;
+      /** @type {number} */
+
+      this.date;
+      /** @type {number} */
+
+      this.crc32;
+      /** @type {number} */
+
+      this.compressedSize;
+      /** @type {number} */
+
+      this.plainSize;
+      /** @type {number} */
+
+      this.fileNameLength;
+      /** @type {number} */
+
+      this.extraFieldLength;
+      /** @type {number} */
+
+      this.fileCommentLength;
+      /** @type {number} */
+
+      this.diskNumberStart;
+      /** @type {number} */
+
+      this.internalFileAttributes;
+      /** @type {number} */
+
+      this.externalFileAttributes;
+      /** @type {number} */
+
+      this.relativeOffset;
+      /** @type {string} */
+
+      this.filename;
+      /** @type {!(Array.<number>|Uint8Array)} */
+
+      this.extraField;
+      /** @type {!(Array.<number>|Uint8Array)} */
+
+      this.comment;
+    };
+
+    Zlib.Unzip.FileHeader.prototype.parse = function () {
+      /** @type {!(Array.<number>|Uint8Array)} */
+      var input = this.input;
+      /** @type {number} */
+
+      var ip = this.offset; // central file header signature
+
+      if (input[ip++] !== Zlib.Unzip.FileHeaderSignature[0] || input[ip++] !== Zlib.Unzip.FileHeaderSignature[1] || input[ip++] !== Zlib.Unzip.FileHeaderSignature[2] || input[ip++] !== Zlib.Unzip.FileHeaderSignature[3]) {
+        throw new Error('invalid file header signature');
+      } // version made by
+
+
+      this.version = input[ip++];
+      this.os = input[ip++]; // version needed to extract
+
+      this.needVersion = input[ip++] | input[ip++] << 8; // general purpose bit flag
+
+      this.flags = input[ip++] | input[ip++] << 8; // compression method
+
+      this.compression = input[ip++] | input[ip++] << 8; // last mod file time
+
+      this.time = input[ip++] | input[ip++] << 8; //last mod file date
+
+      this.date = input[ip++] | input[ip++] << 8; // crc-32
+
+      this.crc32 = (input[ip++] | input[ip++] << 8 | input[ip++] << 16 | input[ip++] << 24) >>> 0; // compressed size
+
+      this.compressedSize = (input[ip++] | input[ip++] << 8 | input[ip++] << 16 | input[ip++] << 24) >>> 0; // uncompressed size
+
+      this.plainSize = (input[ip++] | input[ip++] << 8 | input[ip++] << 16 | input[ip++] << 24) >>> 0; // file name length
+
+      this.fileNameLength = input[ip++] | input[ip++] << 8; // extra field length
+
+      this.extraFieldLength = input[ip++] | input[ip++] << 8; // file comment length
+
+      this.fileCommentLength = input[ip++] | input[ip++] << 8; // disk number start
+
+      this.diskNumberStart = input[ip++] | input[ip++] << 8; // internal file attributes
+
+      this.internalFileAttributes = input[ip++] | input[ip++] << 8; // external file attributes
+
+      this.externalFileAttributes = input[ip++] | input[ip++] << 8 | input[ip++] << 16 | input[ip++] << 24; // relative offset of local header
+
+      this.relativeOffset = (input[ip++] | input[ip++] << 8 | input[ip++] << 16 | input[ip++] << 24) >>> 0; // file name
+
+      this.filename = String.fromCharCode.apply(null, input.subarray(ip, ip += this.fileNameLength)); // extra field
+
+      this.extraField = input.subarray(ip, ip += this.extraFieldLength); // file comment
+
+      this.comment = input.subarray(ip, ip + this.fileCommentLength);
+      this.length = ip - this.offset;
+    };
+    /**
+     * @param {!(Array.<number>|Uint8Array)} input input buffer.
+     * @param {number} ip input position.
+     * @constructor
+     */
+
+
+    Zlib.Unzip.LocalFileHeader = function (input, ip) {
+      /** @type {!(Array.<number>|Uint8Array)} */
+      this.input = input;
+      /** @type {number} */
+
+      this.offset = ip;
+      /** @type {number} */
+
+      this.length;
+      /** @type {number} */
+
+      this.needVersion;
+      /** @type {number} */
+
+      this.flags;
+      /** @type {number} */
+
+      this.compression;
+      /** @type {number} */
+
+      this.time;
+      /** @type {number} */
+
+      this.date;
+      /** @type {number} */
+
+      this.crc32;
+      /** @type {number} */
+
+      this.compressedSize;
+      /** @type {number} */
+
+      this.plainSize;
+      /** @type {number} */
+
+      this.fileNameLength;
+      /** @type {number} */
+
+      this.extraFieldLength;
+      /** @type {string} */
+
+      this.filename;
+      /** @type {!(Array.<number>|Uint8Array)} */
+
+      this.extraField;
+    };
+
+    Zlib.Unzip.LocalFileHeader.Flags = Zlib.Zip.Flags;
+
+    Zlib.Unzip.LocalFileHeader.prototype.parse = function () {
+      /** @type {!(Array.<number>|Uint8Array)} */
+      var input = this.input;
+      /** @type {number} */
+
+      var ip = this.offset; // local file header signature
+
+      if (input[ip++] !== Zlib.Unzip.LocalFileHeaderSignature[0] || input[ip++] !== Zlib.Unzip.LocalFileHeaderSignature[1] || input[ip++] !== Zlib.Unzip.LocalFileHeaderSignature[2] || input[ip++] !== Zlib.Unzip.LocalFileHeaderSignature[3]) {
+        throw new Error('invalid local file header signature');
+      } // version needed to extract
+
+
+      this.needVersion = input[ip++] | input[ip++] << 8; // general purpose bit flag
+
+      this.flags = input[ip++] | input[ip++] << 8; // compression method
+
+      this.compression = input[ip++] | input[ip++] << 8; // last mod file time
+
+      this.time = input[ip++] | input[ip++] << 8; //last mod file date
+
+      this.date = input[ip++] | input[ip++] << 8; // crc-32
+
+      this.crc32 = (input[ip++] | input[ip++] << 8 | input[ip++] << 16 | input[ip++] << 24) >>> 0; // compressed size
+
+      this.compressedSize = (input[ip++] | input[ip++] << 8 | input[ip++] << 16 | input[ip++] << 24) >>> 0; // uncompressed size
+
+      this.plainSize = (input[ip++] | input[ip++] << 8 | input[ip++] << 16 | input[ip++] << 24) >>> 0; // file name length
+
+      this.fileNameLength = input[ip++] | input[ip++] << 8; // extra field length
+
+      this.extraFieldLength = input[ip++] | input[ip++] << 8; // file name
+
+      this.filename = String.fromCharCode.apply(null, input.subarray(ip, ip += this.fileNameLength)); // extra field
+
+      this.extraField = input.subarray(ip, ip += this.extraFieldLength);
+      this.length = ip - this.offset;
+    };
+
+    Zlib.Unzip.prototype.searchEndOfCentralDirectoryRecord = function () {
+      /** @type {!(Array.<number>|Uint8Array)} */
+      var input = this.input;
+      /** @type {number} */
+
+      var ip;
+
+      for (ip = input.length - 12; ip > 0; --ip) {
+        if (input[ip] === Zlib.Unzip.CentralDirectorySignature[0] && input[ip + 1] === Zlib.Unzip.CentralDirectorySignature[1] && input[ip + 2] === Zlib.Unzip.CentralDirectorySignature[2] && input[ip + 3] === Zlib.Unzip.CentralDirectorySignature[3]) {
+          this.eocdrOffset = ip;
+          return;
+        }
+      }
+
+      throw new Error('End of Central Directory Record not found');
+    };
+
+    Zlib.Unzip.prototype.parseEndOfCentralDirectoryRecord = function () {
+      /** @type {!(Array.<number>|Uint8Array)} */
+      var input = this.input;
+      /** @type {number} */
+
+      var ip;
+
+      if (!this.eocdrOffset) {
+        this.searchEndOfCentralDirectoryRecord();
+      }
+
+      ip = this.eocdrOffset; // signature
+
+      if (input[ip++] !== Zlib.Unzip.CentralDirectorySignature[0] || input[ip++] !== Zlib.Unzip.CentralDirectorySignature[1] || input[ip++] !== Zlib.Unzip.CentralDirectorySignature[2] || input[ip++] !== Zlib.Unzip.CentralDirectorySignature[3]) {
+        throw new Error('invalid signature');
+      } // number of this disk
+
+
+      this.numberOfThisDisk = input[ip++] | input[ip++] << 8; // number of the disk with the start of the central directory
+
+      this.startDisk = input[ip++] | input[ip++] << 8; // total number of entries in the central directory on this disk
+
+      this.totalEntriesThisDisk = input[ip++] | input[ip++] << 8; // total number of entries in the central directory
+
+      this.totalEntries = input[ip++] | input[ip++] << 8; // size of the central directory
+
+      this.centralDirectorySize = (input[ip++] | input[ip++] << 8 | input[ip++] << 16 | input[ip++] << 24) >>> 0; // offset of start of central directory with respect to the starting disk number
+
+      this.centralDirectoryOffset = (input[ip++] | input[ip++] << 8 | input[ip++] << 16 | input[ip++] << 24) >>> 0; // .ZIP file comment length
+
+      this.commentLength = input[ip++] | input[ip++] << 8; // .ZIP file comment
+
+      this.comment = input.subarray(ip, ip + this.commentLength);
+    };
+
+    Zlib.Unzip.prototype.parseFileHeader = function () {
+      /** @type {Array.<Zlib.Unzip.FileHeader>} */
+      var filelist = [];
+      /** @type {Object.<string, number>} */
+
+      var filetable = {};
+      /** @type {number} */
+
+      var ip;
+      /** @type {Zlib.Unzip.FileHeader} */
+
+      var fileHeader;
+      /*: @type {number} */
+
+      var i;
+      /*: @type {number} */
+
+      var il;
+
+      if (this.fileHeaderList) {
+        return;
+      }
+
+      if (this.centralDirectoryOffset === void 0) {
+        this.parseEndOfCentralDirectoryRecord();
+      }
+
+      ip = this.centralDirectoryOffset;
+
+      for (i = 0, il = this.totalEntries; i < il; ++i) {
+        fileHeader = new Zlib.Unzip.FileHeader(this.input, ip);
+        fileHeader.parse();
+        ip += fileHeader.length;
+        filelist[i] = fileHeader;
+        filetable[fileHeader.filename] = i;
+      }
+
+      if (this.centralDirectorySize < ip - this.centralDirectoryOffset) {
+        throw new Error('invalid file header size');
+      }
+
+      this.fileHeaderList = filelist;
+      this.filenameToIndex = filetable;
+    };
+    /**
+     * @param {number} index file header index.
+     * @param {Object=} opt_params
+     * @return {!(Array.<number>|Uint8Array)} file data.
+     */
+
+
+    Zlib.Unzip.prototype.getFileData = function (index, opt_params) {
+      opt_params = opt_params || {};
+      /** @type {!(Array.<number>|Uint8Array)} */
+
+      var input = this.input;
+      /** @type {Array.<Zlib.Unzip.FileHeader>} */
+
+      var fileHeaderList = this.fileHeaderList;
+      /** @type {Zlib.Unzip.LocalFileHeader} */
+
+      var localFileHeader;
+      /** @type {number} */
+
+      var offset;
+      /** @type {number} */
+
+      var length;
+      /** @type {!(Array.<number>|Uint8Array)} */
+
+      var buffer;
+      /** @type {number} */
+
+      var crc32;
+      /** @type {Array.<number>|Uint32Array|Object} */
+
+      var key;
+      /** @type {number} */
+
+      var i;
+      /** @type {number} */
+
+      var il;
+
+      if (!fileHeaderList) {
+        this.parseFileHeader();
+      }
+
+      if (fileHeaderList[index] === void 0) {
+        throw new Error('wrong index');
+      }
+
+      offset = fileHeaderList[index].relativeOffset;
+      localFileHeader = new Zlib.Unzip.LocalFileHeader(this.input, offset);
+      localFileHeader.parse();
+      offset += localFileHeader.length;
+      length = localFileHeader.compressedSize; // decryption
+
+      if ((localFileHeader.flags & Zlib.Unzip.LocalFileHeader.Flags.ENCRYPT) !== 0) {
+        if (!(opt_params['password'] || this.password)) {
+          throw new Error('please set password');
+        }
+
+        key = this.createDecryptionKey(opt_params['password'] || this.password); // encryption header
+
+        for (i = offset, il = offset + 12; i < il; ++i) {
+          this.decode(key, input[i]);
+        }
+
+        offset += 12;
+        length -= 12; // decryption
+
+        for (i = offset, il = offset + length; i < il; ++i) {
+          input[i] = this.decode(key, input[i]);
+        }
+      }
+
+      switch (localFileHeader.compression) {
+        case Zlib.Unzip.CompressionMethod.STORE:
+          buffer = this.input.subarray(offset, offset + length);
+          break;
+
+        case Zlib.Unzip.CompressionMethod.DEFLATE:
+          buffer = new Zlib.RawInflate(this.input, {
+            'index': offset,
+            'bufferSize': localFileHeader.plainSize
+          }).decompress();
+          break;
+
+        default:
+          throw new Error('unknown compression type');
+      }
+
+      if (this.verify) {
+        crc32 = Zlib.CRC32.calc(buffer);
+
+        if (localFileHeader.crc32 !== crc32) {
+          throw new Error('wrong crc: file=0x' + localFileHeader.crc32.toString(16) + ', data=0x' + crc32.toString(16));
+        }
+      }
+
+      return buffer;
+    };
+    /**
+     * @return {Array.<string>}
+     */
+
+
+    Zlib.Unzip.prototype.getFilenames = function () {
+      /** @type {Array.<string>} */
+      var filenameList = [];
+      /** @type {number} */
+
+      var i;
+      /** @type {number} */
+
+      var il;
+      /** @type {Array.<Zlib.Unzip.FileHeader>} */
+
+      var fileHeaderList;
+
+      if (!this.fileHeaderList) {
+        this.parseFileHeader();
+      }
+
+      fileHeaderList = this.fileHeaderList;
+
+      for (i = 0, il = fileHeaderList.length; i < il; ++i) {
+        filenameList[i] = fileHeaderList[i].filename;
+      }
+
+      return filenameList;
+    };
+    /**
+     * @param {string} filename extract filename.
+     * @param {Object=} opt_params
+     * @return {!(Array.<number>|Uint8Array)} decompressed data.
+     */
+
+
+    Zlib.Unzip.prototype.decompress = function (filename, opt_params) {
+      /** @type {number} */
+      var index;
+
+      if (!this.filenameToIndex) {
+        this.parseFileHeader();
+      }
+
+      index = this.filenameToIndex[filename];
+
+      if (index === void 0) {
+        throw new Error(filename + ' not found');
+      }
+
+      return this.getFileData(index, opt_params);
+    };
+    /**
+     * @param {(Array.<number>|Uint8Array)} password
+     */
+
+
+    Zlib.Unzip.prototype.setPassword = function (password) {
+      this.password = password;
+    };
+    /**
+     * @param {(Array.<number>|Uint32Array|Object)} key
+     * @param {number} n
+     * @return {number}
+     */
+
+
+    Zlib.Unzip.prototype.decode = function (key, n) {
+      n ^= this.getByte(key);
+      this.updateKeys(key, n);
+      return n;
+    }; // common method
+
+
+    Zlib.Unzip.prototype.updateKeys = Zlib.Zip.prototype.updateKeys;
+    Zlib.Unzip.prototype.createDecryptionKey = Zlib.Zip.prototype.createEncryptionKey;
+    Zlib.Unzip.prototype.getByte = Zlib.Zip.prototype.getByte;
+    /**
+     * @fileoverview 雑多な関数群をまとめたモジュール実装.
+     */
+
+    /**
+     * Byte String から Byte Array に変換.
+     * @param {!string} str byte string.
+     * @return {!Array.<number>} byte array.
+     */
+
+    Zlib.Util.stringToByteArray = function (str) {
+      /** @type {!Array.<(string|number)>} */
+      var tmp = str.split('');
+      /** @type {number} */
+
+      var i;
+      /** @type {number} */
+
+      var il;
+
+      for (i = 0, il = tmp.length; i < il; i++) {
+        tmp[i] = (tmp[i].charCodeAt(0) & 0xff) >>> 0;
+      }
+
+      return tmp;
+    };
+    /**
+     * @fileoverview Adler32 checksum 実装.
+     */
+
+    /**
+     * Adler32 ハッシュ値の作成
+     * @param {!(Array|Uint8Array|string)} array 算出に使用する byte array.
+     * @return {number} Adler32 ハッシュ値.
+     */
+
+
+    Zlib.Adler32 = function (array) {
+      if (typeof array === 'string') {
+        array = Zlib.Util.stringToByteArray(array);
+      }
+
+      return Zlib.Adler32.update(1, array);
+    };
+    /**
+     * Adler32 ハッシュ値の更新
+     * @param {number} adler 現在のハッシュ値.
+     * @param {!(Array|Uint8Array)} array 更新に使用する byte array.
+     * @return {number} Adler32 ハッシュ値.
+     */
+
+
+    Zlib.Adler32.update = function (adler, array) {
+      /** @type {number} */
+      var s1 = adler & 0xffff;
+      /** @type {number} */
+
+      var s2 = adler >>> 16 & 0xffff;
+      /** @type {number} array length */
+
+      var len = array.length;
+      /** @type {number} loop length (don't overflow) */
+
+      var tlen;
+      /** @type {number} array index */
+
+      var i = 0;
+
+      while (len > 0) {
+        tlen = len > Zlib.Adler32.OptimizationParameter ? Zlib.Adler32.OptimizationParameter : len;
+        len -= tlen;
+
+        do {
+          s1 += array[i++];
+          s2 += s1;
+        } while (--tlen);
+
+        s1 %= 65521;
+        s2 %= 65521;
+      }
+
+      return (s2 << 16 | s1) >>> 0;
+    };
+    /**
+     * Adler32 最適化パラメータ
+     * 現状では 1024 程度が最適.
+     * @see http://jsperf.com/adler-32-simple-vs-optimized/3
+     * @define {number}
+     */
+
+
+    Zlib.Adler32.OptimizationParameter = 1024;
+    /**
+     * ビットストリーム
+     * @constructor
+     * @param {!(Array|Uint8Array)=} buffer output buffer.
+     * @param {number=} bufferPosition start buffer pointer.
+     */
+
+    Zlib.BitStream = function (buffer, bufferPosition) {
+      /** @type {number} buffer index. */
+      this.index = typeof bufferPosition === 'number' ? bufferPosition : 0;
+      /** @type {number} bit index. */
+
+      this.bitindex = 0;
+      /** @type {!(Array|Uint8Array)} bit-stream output buffer. */
+
+      this.buffer = buffer instanceof Uint8Array ? buffer : new Uint8Array(Zlib.BitStream.DefaultBlockSize); // 入力された index が足りなかったら拡張するが、倍にしてもダメなら不正とする
+
+      if (this.buffer.length * 2 <= this.index) {
+        throw new Error("invalid index");
+      } else if (this.buffer.length <= this.index) {
+        this.expandBuffer();
+      }
+    };
+    /**
+     * デフォルトブロックサイズ.
+     * @const
+     * @type {number}
+     */
+
+
+    Zlib.BitStream.DefaultBlockSize = 0x8000;
+    /**
+     * expand buffer.
+     * @return {!(Array|Uint8Array)} new buffer.
+     */
+
+    Zlib.BitStream.prototype.expandBuffer = function () {
+      /** @type {!(Array|Uint8Array)} old buffer. */
+      var oldbuf = this.buffer;
+      /** @type {number} loop limiter. */
+
+      var il = oldbuf.length;
+      /** @type {!(Array|Uint8Array)} new buffer. */
+
+      var buffer = new Uint8Array(il << 1); // copy buffer
+
+      {
+        buffer.set(oldbuf);
+      }
+      return this.buffer = buffer;
+    };
+    /**
+     * 数値をビットで指定した数だけ書き込む.
+     * @param {number} number 書き込む数値.
+     * @param {number} n 書き込むビット数.
+     * @param {boolean=} reverse é€†é †ã«æ›¸ãè¾¼ã‚€ãªã‚‰ã° true.
+     */
+
+
+    Zlib.BitStream.prototype.writeBits = function (number, n, reverse) {
+      var buffer = this.buffer;
+      var index = this.index;
+      var bitindex = this.bitindex;
+      /** @type {number} current octet. */
+
+      var current = buffer[index];
+      /** @type {number} loop counter. */
+
+      var i;
+      /**
+       * 32-bit æ•´æ•°ã®ãƒ“ãƒƒãƒˆé †ã‚’é€†ã«ã™ã‚‹
+       * @param {number} n 32-bit integer.
+       * @return {number} reversed 32-bit integer.
+       * @private
+       */
+
+      function rev32_(n) {
+        return Zlib.BitStream.ReverseTable[n & 0xFF] << 24 | Zlib.BitStream.ReverseTable[n >>> 8 & 0xFF] << 16 | Zlib.BitStream.ReverseTable[n >>> 16 & 0xFF] << 8 | Zlib.BitStream.ReverseTable[n >>> 24 & 0xFF];
+      }
+
+      if (reverse && n > 1) {
+        number = n > 8 ? rev32_(number) >> 32 - n : Zlib.BitStream.ReverseTable[number] >> 8 - n;
+      } // Byte 境界を超えないとき
+
+
+      if (n + bitindex < 8) {
+        current = current << n | number;
+        bitindex += n; // Byte 境界を超えるとき
+      } else {
+        for (i = 0; i < n; ++i) {
+          current = current << 1 | number >> n - i - 1 & 1; // next byte
+
+          if (++bitindex === 8) {
+            bitindex = 0;
+            buffer[index++] = Zlib.BitStream.ReverseTable[current];
+            current = 0; // expand
+
+            if (index === buffer.length) {
+              buffer = this.expandBuffer();
+            }
+          }
+        }
+      }
+
+      buffer[index] = current;
+      this.buffer = buffer;
+      this.bitindex = bitindex;
+      this.index = index;
+    };
+    /**
+     * ストリームの終端処理を行う
+     * @return {!(Array|Uint8Array)} 終端処理後のバッファを byte array で返す.
+     */
+
+
+    Zlib.BitStream.prototype.finish = function () {
+      var buffer = this.buffer;
+      var index = this.index;
+      /** @type {!(Array|Uint8Array)} output buffer. */
+
+      var output; // bitindex が 0 の時は余分に index が進んでいる状態
+
+      if (this.bitindex > 0) {
+        buffer[index] <<= 8 - this.bitindex;
+        buffer[index] = Zlib.BitStream.ReverseTable[buffer[index]];
+        index++;
+      } // array truncation
+
+
+      {
+        output = buffer.subarray(0, index);
+      }
+      return output;
+    };
+    /**
+     * 0-255 ã®ãƒ“ãƒƒãƒˆé †ã‚’åè»¢ã—ãŸãƒ†ãƒ¼ãƒ–ãƒ«
+     * @const
+     * @type {!(Uint8Array|Array.<number>)}
+     */
+
+
+    Zlib.BitStream.ReverseTable = function (table) {
+      return table;
+    }(function () {
+      /** @type {!(Array|Uint8Array)} reverse table. */
+      var table = new Uint8Array(256);
+      /** @type {number} loop counter. */
+
+      var i; // generate
+
+      for (i = 0; i < 256; ++i) {
+        table[i] = function (n) {
+          var r = n;
+          var s = 7;
+
+          for (n >>>= 1; n; n >>>= 1) {
+            r <<= 1;
+            r |= n & 1;
+            --s;
+          }
+
+          return (r << s & 0xff) >>> 0;
+        }(i);
+      }
+
+      return table;
+    }());
+    /**
+     * CRC32 ハッシュ値を取得
+     * @param {!(Array.<number>|Uint8Array)} data data byte array.
+     * @param {number=} pos data position.
+     * @param {number=} length data length.
+     * @return {number} CRC32.
+     */
+
+
+    Zlib.CRC32.calc = function (data, pos, length) {
+      return Zlib.CRC32.update(data, 0, pos, length);
+    };
+    /**
+     * CRC32ハッシュ値を更新
+     * @param {!(Array.<number>|Uint8Array)} data data byte array.
+     * @param {number} crc CRC32.
+     * @param {number=} pos data position.
+     * @param {number=} length data length.
+     * @return {number} CRC32.
+     */
+
+
+    Zlib.CRC32.update = function (data, crc, pos, length) {
+      var table = Zlib.CRC32.Table;
+      var i = typeof pos === 'number' ? pos : pos = 0;
+      var il = typeof length === 'number' ? length : data.length;
+      crc ^= 0xffffffff; // loop unrolling for performance
+
+      for (i = il & 7; i--; ++pos) {
+        crc = crc >>> 8 ^ table[(crc ^ data[pos]) & 0xff];
+      }
+
+      for (i = il >> 3; i--; pos += 8) {
+        crc = crc >>> 8 ^ table[(crc ^ data[pos]) & 0xff];
+        crc = crc >>> 8 ^ table[(crc ^ data[pos + 1]) & 0xff];
+        crc = crc >>> 8 ^ table[(crc ^ data[pos + 2]) & 0xff];
+        crc = crc >>> 8 ^ table[(crc ^ data[pos + 3]) & 0xff];
+        crc = crc >>> 8 ^ table[(crc ^ data[pos + 4]) & 0xff];
+        crc = crc >>> 8 ^ table[(crc ^ data[pos + 5]) & 0xff];
+        crc = crc >>> 8 ^ table[(crc ^ data[pos + 6]) & 0xff];
+        crc = crc >>> 8 ^ table[(crc ^ data[pos + 7]) & 0xff];
+      }
+
+      return (crc ^ 0xffffffff) >>> 0;
+    };
+    /**
+     * @param {number} num
+     * @param {number} crc
+     * @returns {number}
+     */
+
+
+    Zlib.CRC32.single = function (num, crc) {
+      return (Zlib.CRC32.Table[(num ^ crc) & 0xff] ^ num >>> 8) >>> 0;
+    };
+    /**
+     * @type {Array.<number>}
+     * @const
+     * @private
+     */
+
+
+    Zlib.CRC32.Table_ = [0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de, 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9, 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, 0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599, 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924, 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190, 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01, 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950, 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010, 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f, 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8, 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb, 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, 0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef, 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236, 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe, 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713, 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242, 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9, 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d];
+    /**
+     * @type {!(Array.<number>|Uint32Array)} CRC-32 Table.
+     * @const
+     */
+
+    Zlib.CRC32.Table = new Uint32Array(Zlib.CRC32.Table_);
+    /**
+     * @fileoverview Deflate (RFC1951) 実装.
+     * Deflateアルゴリズム本体は Zlib.RawDeflate で実装されている.
+     */
+
+    /**
+     * Zlib Deflate
+     * @constructor
+     * @param {!(Array|Uint8Array)} input 符号化する対象の byte array.
+     * @param {Object=} opt_params option parameters.
+     */
+
+    Zlib.Deflate = function (input, opt_params) {
+      /** @type {!(Array|Uint8Array)} */
+      this.input = input;
+      /** @type {!(Array|Uint8Array)} */
+
+      this.output = new Uint8Array(Zlib.Deflate.DefaultBufferSize);
+      /** @type {Zlib.Deflate.CompressionType} */
+
+      this.compressionType = Zlib.Deflate.CompressionType.DYNAMIC;
+      /** @type {Zlib.RawDeflate} */
+
+      this.rawDeflate;
+      /** @type {Object} */
+
+      var rawDeflateOption = {};
+      /** @type {string} */
+
+      var prop; // option parameters
+
+      if (opt_params || !(opt_params = {})) {
+        if (typeof opt_params['compressionType'] === 'number') {
+          this.compressionType = opt_params['compressionType'];
+        }
+      } // copy options
+
+
+      for (prop in opt_params) {
+        rawDeflateOption[prop] = opt_params[prop];
+      } // set raw-deflate output buffer
+
+
+      rawDeflateOption['outputBuffer'] = this.output;
+      this.rawDeflate = new Zlib.RawDeflate(this.input, rawDeflateOption);
+    };
+    /**
+     * @const
+     * @type {number} デフォルトバッファサイズ.
+     */
+
+
+    Zlib.Deflate.DefaultBufferSize = 0x8000;
+    /**
+     * @enum {number}
+     */
+
+    Zlib.Deflate.CompressionType = Zlib.RawDeflate.CompressionType;
+    /**
+     * 直接圧縮に掛ける.
+     * @param {!(Array|Uint8Array)} input target buffer.
+     * @param {Object=} opt_params option parameters.
+     * @return {!(Array|Uint8Array)} compressed data byte array.
+     */
+
+    Zlib.Deflate.compress = function (input, opt_params) {
+      return new Zlib.Deflate(input, opt_params).compress();
+    };
+    /**
+     * Deflate Compression.
+     * @return {!(Array|Uint8Array)} compressed data byte array.
+     */
+
+
+    Zlib.Deflate.prototype.compress = function () {
+      /** @type {Zlib.CompressionMethod} */
+      var cm;
+      /** @type {number} */
+
+      var cinfo;
+      /** @type {number} */
+
+      var cmf;
+      /** @type {number} */
+
+      var flg;
+      /** @type {number} */
+
+      var fcheck;
+      /** @type {number} */
+
+      var fdict;
+      /** @type {number} */
+
+      var flevel;
+      /** @type {number} */
+
+      var adler;
+      /** @type {!(Array|Uint8Array)} */
+
+      var output;
+      /** @type {number} */
+
+      var pos = 0;
+      output = this.output; // Compression Method and Flags
+
+      cm = Zlib.CompressionMethod.DEFLATE;
+
+      switch (cm) {
+        case Zlib.CompressionMethod.DEFLATE:
+          cinfo = Math.LOG2E * Math.log(Zlib.RawDeflate.WindowSize) - 8;
+          break;
+
+        default:
+          throw new Error('invalid compression method');
+      }
+
+      cmf = cinfo << 4 | cm;
+      output[pos++] = cmf; // Flags
+
+      fdict = 0;
+
+      switch (cm) {
+        case Zlib.CompressionMethod.DEFLATE:
+          switch (this.compressionType) {
+            case Zlib.Deflate.CompressionType.NONE:
+              flevel = 0;
+              break;
+
+            case Zlib.Deflate.CompressionType.FIXED:
+              flevel = 1;
+              break;
+
+            case Zlib.Deflate.CompressionType.DYNAMIC:
+              flevel = 2;
+              break;
+
+            default:
+              throw new Error('unsupported compression type');
+          }
+
+          break;
+
+        default:
+          throw new Error('invalid compression method');
+      }
+
+      flg = flevel << 6 | fdict << 5;
+      fcheck = 31 - (cmf * 256 + flg) % 31;
+      flg |= fcheck;
+      output[pos++] = flg; // Adler-32 checksum
+
+      adler = Zlib.Adler32(this.input);
+      this.rawDeflate.op = pos;
+      output = this.rawDeflate.compress();
+      pos = output.length;
+      {
+        // subarray 分を元にもどす
+        output = new Uint8Array(output.buffer); // expand buffer
+
+        if (output.length <= pos + 4) {
+          this.output = new Uint8Array(output.length + 4);
+          this.output.set(output);
+          output = this.output;
+        }
+
+        output = output.subarray(0, pos + 4);
+      } // adler32
+
+      output[pos++] = adler >> 24 & 0xff;
+      output[pos++] = adler >> 16 & 0xff;
+      output[pos++] = adler >> 8 & 0xff;
+      output[pos++] = adler & 0xff;
+      return output;
+    }; //	%23	%24	%25	%26	%27	%28	%29	%2A	%2B	%2C	%2F	%3A	%3B	%3D	%3F	%40	%5B	%5D
+
+
+    const encodings = new Map();
+    encodings.set("!", "%21");
+    encodings.set("#", "%23");
+    encodings.set("$", "%24");
+    encodings.set("%", "%25");
+    encodings.set("&", "%26");
+    encodings.set("'", "%27");
+    encodings.set("(", "%28");
+    encodings.set(")", "%29");
+    encodings.set("*", "%2A");
+    encodings.set("+", "%2B");
+    encodings.set(",", "%2C");
+    encodings.set("/", "%2F");
+    encodings.set(":", "%3A");
+    encodings.set(";", "%3B");
+    encodings.set("=", "%3D");
+    encodings.set("?", "%3F");
+    encodings.set("@", "%40");
+    encodings.set("[", "%5B");
+    encodings.set("]", "%5D");
+    encodings.set(" ", "%20");
+
+    if (typeof process === 'object' && typeof window === 'undefined') {
+      global.atob = function (str) {
+        return Buffer.from(str, 'base64').toString('binary');
+      };
+    }
+    /**
+     * Make the target element movable by clicking and dragging on the handle.  This is not a general purprose function,
+     * it makes several options specific to igv dialogs, the primary one being that the
+     * target is absolutely positioned in pixel coordinates
+
+     */
+
+
+    let dragData; // Its assumed we are only dragging one element at a time.
+
+    function makeDraggable(target, handle) {
+      handle.addEventListener('mousedown', dragStart.bind(target));
+    }
+
+    function dragStart(event) {
+      event.stopPropagation();
+      event.preventDefault();
+      offset(this);
+      const dragFunction = drag.bind(this);
+      const dragEndFunction = dragEnd.bind(this);
+      const computedStyle = getComputedStyle(this);
+      const top = parseInt(computedStyle.top.replace("px", ""));
+      const left = parseInt(computedStyle.left.replace("px", ""));
+      dragData = {
+        dragFunction: dragFunction,
+        dragEndFunction: dragEndFunction,
+        screenX: event.screenX,
+        screenY: event.screenY,
+        top: top,
+        left: left
+      };
+      document.addEventListener('mousemove', dragFunction);
+      document.addEventListener('mouseup', dragEndFunction);
+      document.addEventListener('mouseleave', dragEndFunction);
+      document.addEventListener('mouseexit', dragEndFunction);
+    }
+
+    function drag(event) {
+      if (!dragData) {
+        return;
+      }
+
+      event.stopPropagation();
+      event.preventDefault();
+      const dx = event.screenX - dragData.screenX;
+      const dy = event.screenY - dragData.screenY;
+      this.style.left = `${dragData.left + dx}px`;
+      this.style.top = `${dragData.top + dy}px`;
+    }
+
+    function dragEnd(event) {
+      if (!dragData) {
+        return;
+      }
+
+      event.stopPropagation();
+      event.preventDefault();
+      const dragFunction = dragData.dragFunction;
+      const dragEndFunction = dragData.dragEndFunction;
+      document.removeEventListener('mousemove', dragFunction);
+      document.removeEventListener('mouseup', dragEndFunction);
+      document.removeEventListener('mouseleave', dragEndFunction);
+      document.removeEventListener('mouseexit', dragEndFunction);
+      dragData = undefined;
+    }
+
+    const appleCrayonPalette = {
+      licorice: "#000000",
+      lead: "#1e1e1e",
+      tungsten: "#3a3a3a",
+      iron: "#545453",
+      steel: "#6e6e6e",
+      tin: "#878687",
+      nickel: "#888787",
+      aluminum: "#a09fa0",
+      magnesium: "#b8b8b8",
+      silver: "#d0d0d0",
+      mercury: "#e8e8e8",
+      snow: "#ffffff",
+      //
+      cayenne: "#891100",
+      mocha: "#894800",
+      aspargus: "#888501",
+      fern: "#458401",
+      clover: "#028401",
+      moss: "#018448",
+      teal: "#008688",
+      ocean: "#004a88",
+      midnight: "#001888",
+      eggplant: "#491a88",
+      plum: "#891e88",
+      maroon: "#891648",
+      //
+      maraschino: "#ff2101",
+      tangerine: "#ff8802",
+      lemon: "#fffa03",
+      lime: "#83f902",
+      spring: "#05f802",
+      seam_foam: "#03f987",
+      turquoise: "#00fdff",
+      aqua: "#008cff",
+      blueberry: "#002eff",
+      grape: "#8931ff",
+      magenta: "#ff39ff",
+      strawberry: "#ff2987",
+      //
+      salmon: "#ff726e",
+      cantaloupe: "#ffce6e",
+      banana: "#fffb6d",
+      honeydew: "#cefa6e",
+      flora: "#68f96e",
+      spindrift: "#68fbd0",
+      ice: "#68fdff",
+      sky: "#6acfff",
+      orchid: "#6e76ff",
+      lavender: "#d278ff",
+      bubblegum: "#ff7aff",
+      carnation: "#ff7fd3"
+    }; // The MIT License (MIT)
+
+    /**
+     * @constructor
+     * @param {Object} options A set op options to pass to the throttle function
+     *        @param {number} requestsPerSecond The amount of requests per second
+     *                                          the library will limit to
+     */
+
+    class Throttle {
+      constructor(options) {
+        this.requestsPerSecond = options.requestsPerSecond || 10;
+        this.lastStartTime = 0;
+        this.queued = [];
+      }
+      /**
+       * Adds a promise
+       * @param {Function} async function to be executed
+       * @param {Object} options A set of options.
+       * @return {Promise} A promise
+       */
+
+
+      add(asyncFunction, options) {
+        var self = this;
+        return new Promise(function (resolve, reject) {
+          self.queued.push({
+            resolve: resolve,
+            reject: reject,
+            asyncFunction: asyncFunction
+          });
+          self.dequeue();
+        });
+      }
+      /**
+       * Adds all the promises passed as parameters
+       * @param {Function} promises An array of functions that return a promise
+       * @param {Object} options A set of options.
+       * @param {number} options.signal An AbortSignal object that can be used to abort the returned promise
+       * @param {number} options.weight A "weight" of each operation resolving by array of promises
+       * @return {Promise} A promise that succeeds when all the promises passed as options do
+       */
+
+
+      addAll(promises, options) {
+        var addedPromises = promises.map(function (promise) {
+          return this.add(promise, options);
+        }.bind(this));
+        return Promise.all(addedPromises);
+      }
+
+      /**
+       * Dequeues a promise
+       * @return {void}
+       */
+      dequeue() {
+        if (this.queued.length > 0) {
+          var now = new Date(),
+              inc = 1000 / this.requestsPerSecond + 1,
+              elapsed = now - this.lastStartTime;
+
+          if (elapsed >= inc) {
+            this._execute();
+          } else {
+            // we have reached the limit, schedule a dequeue operation
+            setTimeout(function () {
+              this.dequeue();
+            }.bind(this), inc - elapsed);
+          }
+        }
+      }
+      /**
+       * Executes the promise
+       * @private
+       * @return {void}
+       */
+
+
+      async _execute() {
+        this.lastStartTime = new Date();
+        var candidate = this.queued.shift();
+        const f = candidate.asyncFunction;
+
+        try {
+          const r = await f();
+          candidate.resolve(r);
+        } catch (e) {
+          candidate.reject(e);
+        }
+      }
+
+    }
+    /*
+     * The MIT License (MIT)
+     *
+     * Copyright (c) 2014 Broad Institute
+     *
+     * Permission is hereby granted, free of charge, to any person obtaining a copy
+     * of this software and associated documentation files (the "Software"), to deal
+     * in the Software without restriction, including without limitation the rights
+     * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+     * copies of the Software, and to permit persons to whom the Software is
+     * furnished to do so, subject to the following conditions:
+     *
+     * The above copyright notice and this permission notice shall be included in
+     * all copies or substantial portions of the Software.
+     *
+     *
+     * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+     * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+     * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+     * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+     * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+     * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+     * THE SOFTWARE.
+     */
+
+
+    new Throttle({
+      requestsPerSecond: 8
+    });
+
+    const httpMessages = {
+      "401": "Access unauthorized",
+      "403": "Access forbidden",
+      "404": "Not found"
+    };
+
+    class AlertDialog {
+      constructor(parent) {
+        // container
+        this.container = div({
+          class: "igv-ui-alert-dialog-container"
+        });
+        parent.appendChild(this.container);
+        this.container.setAttribute('tabIndex', '-1'); // header
+
+        const header = div();
+        this.container.appendChild(header);
+        this.errorHeadline = div();
+        header.appendChild(this.errorHeadline);
+        this.errorHeadline.textContent = ''; // body container
+
+        let bodyContainer = div({
+          id: 'igv-ui-alert-dialog-body'
+        });
+        this.container.appendChild(bodyContainer); // body copy
+
+        this.body = div({
+          id: 'igv-ui-alert-dialog-body-copy'
+        });
+        bodyContainer.appendChild(this.body); // ok container
+
+        let ok_container = div();
+        this.container.appendChild(ok_container); // ok
+
+        this.ok = div();
+        ok_container.appendChild(this.ok);
+        this.ok.textContent = 'OK';
+
+        const okHandler = () => {
+          if (typeof this.callback === 'function') {
+            this.callback("OK");
+            this.callback = undefined;
+          }
+
+          this.body.innerHTML = '';
+          hide(this.container);
+        };
+
+        this.ok.addEventListener('click', event => {
+          event.stopPropagation();
+          okHandler();
+        });
+        this.container.addEventListener('keypress', event => {
+          event.stopPropagation();
+
+          if ('Enter' === event.key) {
+            okHandler();
+          }
+        });
+        makeDraggable(this.container, header);
+        hide(this.container);
+      }
+
+      present(alert, callback) {
+        this.errorHeadline.textContent = alert.message ? 'ERROR' : '';
+        let string = alert.message || alert;
+
+        if (httpMessages.hasOwnProperty(string)) {
+          string = httpMessages[string];
+        }
+
+        this.body.innerHTML = string;
+        this.callback = callback;
+        show(this.container);
+        this.container.focus();
+      }
+
+    }
+
+    let alertDialog;
+    const Alert = {
+      init(root) {
+        if (!alertDialog) {
+          alertDialog = new AlertDialog(root);
+        }
+      },
+
+      presentAlert(alert, callback) {
+        if (!alertDialog) {
+          this.init(document.body);
+        }
+
+        alertDialog.present(alert, callback);
+      }
+
+    };
+
+    class InputDialog {
+      constructor(parent) {
+        this.parent = parent; // dialog container
+
+        this.container = div({
+          class: 'igv-ui-generic-dialog-container'
+        });
+        parent.appendChild(this.container); // const { x, y, width, height } = this.container.getBoundingClientRect();
+        // console.log(`InputDialog - x ${ x } y ${ y } width ${ width } height ${ height }`)
+        // dialog header
+
+        const header = div({
+          class: 'igv-ui-generic-dialog-header'
+        });
+        this.container.appendChild(header); // dialog label
+
+        this.label = div({
+          class: 'igv-ui-generic-dialog-one-liner'
+        });
+        this.container.appendChild(this.label);
+        this.label.text = 'Unlabeled'; // input container
+
+        this.input_container = div({
+          class: 'igv-ui-generic-dialog-input'
+        });
+        this.container.appendChild(this.input_container); //
+
+        this.input = document.createElement("input");
+        this.input_container.appendChild(this.input); // ok | cancel
+
+        const buttons = div({
+          class: 'igv-ui-generic-dialog-ok-cancel'
+        });
+        this.container.appendChild(buttons); // ok
+
+        this.ok = div();
+        buttons.appendChild(this.ok);
+        this.ok.textContent = 'OK'; // cancel
+
+        this.cancel = div();
+        buttons.appendChild(this.cancel);
+        this.cancel.textContent = 'Cancel';
+        hide(this.container);
+        this.input.addEventListener('keyup', e => {
+          if (13 === e.keyCode) {
+            if (typeof this.callback === 'function') {
+              this.callback(this.input.value);
+              this.callback = undefined;
+            }
+
+            this.input.value = undefined;
+            hide(this.container);
+          }
+        });
+        this.ok.addEventListener('click', () => {
+          if (typeof this.callback === 'function') {
+            this.callback(this.input.value);
+            this.callback = undefined;
+          }
+
+          this.input.value = undefined;
+          hide(this.container);
+        });
+
+        const cancel = () => {
+          this.input.value = '';
+          hide(this.container);
+        };
+
+        this.cancel.addEventListener('click', cancel);
+        attachDialogCloseHandlerWithParent(header, cancel);
+        makeDraggable(this.container, header);
+      }
+
+      present(options, e) {
+        this.label.textContent = options.label;
+        this.input.value = options.value;
+        this.callback = options.callback || options.click;
+        show(this.container);
+        const {
+          x,
+          y
+        } = pageCoordinates(e);
+        this.clampLocation(x, y);
+      }
+
+      clampLocation(pageX, pageY) {
+        const {
+          width: w,
+          height: h
+        } = this.container.getBoundingClientRect();
+        const {
+          x: px,
+          y: py,
+          width: pw,
+          height: ph
+        } = this.parent.getBoundingClientRect();
+        const y = Math.min(Math.max(pageY, py), py + ph - h);
+        const x = Math.min(Math.max(pageX, px), px + pw - w);
+        this.container.style.left = `${x}px`;
+        this.container.style.top = `${y}px`;
+      }
+
+    }
+
+    class GenericContainer {
+      constructor({
+        parent,
+        top,
+        left,
+        width,
+        height,
+        border,
+        closeHandler
+      }) {
+        let container = div({
+          class: 'igv-ui-generic-container'
+        });
+        parent.appendChild(container);
+        hide(container);
+        this.container = container;
+
+        if (top !== undefined) {
+          this.container.style.top = `${top}px`;
+        }
+
+        if (left !== undefined) {
+          this.container.style.left = `${left}px`;
+        }
+
+        if (width !== undefined) {
+          this.container.style.width = `${width}px`;
+        }
+
+        if (height !== undefined) {
+          this.container.style.height = `${height}px`;
+        }
+
+        if (border) {
+          this.container.style.border = border;
+        } //
+        // let bbox = parent.getBoundingClientRect();
+        // this.origin = {x: bbox.x, y: bbox.y};
+        // this.container.offset({left: this.origin.x, top: this.origin.y});
+        // header
+
+
+        const header = div();
+        this.container.appendChild(header); // close button
+
+        attachDialogCloseHandlerWithParent(header, e => {
+          hide(this.container);
+
+          if (typeof closeHandler === "function") {
+            closeHandler(e);
+          }
+        });
+        makeDraggable(this.container, header);
+      }
+
+      show() {
+        show(this.container);
+      }
+
+      hide() {
+        hide(this.container);
+      }
+
+      dispose() {
+        if (this.container.parent) {
+          this.container.parent.removeChild(this.container);
+        }
+      }
+
+    }
+
+    class ColorPicker extends GenericContainer {
+      constructor({
+        parent,
+        top,
+        left,
+        width,
+        height,
+        defaultColors,
+        colorHandler
+      }) {
+        super({
+          parent,
+          top,
+          left,
+          width,
+          height,
+          border: '1px solid gray'
+        });
+        createColorSwatchSelector(this.container, colorHandler, defaultColors);
+      }
+
+    }
+
+    const createColorSwatchSelector = (container, colorHandler, defaultColors) => {
+      const hexColorStrings = Object.values(appleCrayonPalette);
+
+      for (let hexColorString of hexColorStrings) {
+        const swatch = div({
+          class: 'igv-ui-color-swatch'
+        });
+        container.appendChild(swatch);
+        decorateSwatch(swatch, hexColorString, colorHandler);
+      }
+
+      if (defaultColors) {
+        for (let hexColorString of defaultColors) {
+          const swatch = div({
+            class: 'igv-ui-color-swatch'
+          });
+          container.appendChild(swatch);
+          decorateSwatch(swatch, hexColorString, colorHandler);
+        }
+      }
+    };
+
+    const decorateSwatch = (swatch, hexColorString, colorHandler) => {
+      swatch.style.backgroundColor = hexColorString;
+      swatch.addEventListener('mouseenter', e => swatch.style.borderColor = hexColorString);
+      swatch.addEventListener('mouseleave', e => swatch.style.borderColor = 'white');
+      swatch.addEventListener('click', event => {
+        event.stopPropagation();
+        colorHandler(hexColorString);
+      });
+      swatch.addEventListener('touchend', event => {
+        event.stopPropagation();
+        colorHandler(hexColorString);
+      });
+    };
+
+    class Popover {
+      constructor(parent, title) {
+        this.parent = parent; // popover
+
+        this.popover = div({
+          class: "igv-ui-popover"
+        });
+        parent.appendChild(this.popover); // header
+
+        const popoverHeader = div();
+        this.popover.appendChild(popoverHeader);
+        const titleElement = div();
+        popoverHeader.appendChild(titleElement);
+
+        if (title) {
+          titleElement.textContent = title;
+        }
+
+        attachDialogCloseHandlerWithParent(popoverHeader, () => this.hide());
+        makeDraggable(this.popover, popoverHeader); // content
+
+        this.popoverContent = div();
+        this.popover.appendChild(this.popoverContent);
+        this.popover.style.display = 'none';
+      }
+
+      presentContentWithEvent(e, content) {
+        this.popover.style.display = 'block';
+        this.popoverContent.innerHTML = content;
+        present$1(e, this.popover);
+      }
+
+      presentMenu(e, menuItems) {
+        if (0 === menuItems.length) {
+          return;
+        }
+
+        this.popover.style.display = 'block';
+        const menuElements = createMenuElements$1(menuItems, this.popover);
+
+        for (let item of menuElements) {
+          this.popoverContent.appendChild(item.object);
+        }
+
+        present$1(e, this.popover);
+      }
+
+      hide() {
+        this.popover.style.display = 'none';
+        this.dispose();
+      }
+
+      dispose() {
+        if (this.popover) {
+          this.popover.parentNode.removeChild(this.popover);
+        }
+
+        const keys = Object.keys(this);
+
+        for (let key of keys) {
+          this[key] = undefined;
+        }
+      }
+
+    }
+
+    function present$1(e, popover) {
+      const {
+        x,
+        y
+      } = translateMouseCoordinates(e, popover.parentNode); // parent bbox
+
+      const {
+        width
+      } = popover.parentNode.getBoundingClientRect();
+      const {
+        width: w
+      } = popover.getBoundingClientRect();
+      const xmax = x + w;
+      popover.style.left = `${xmax > width ? x - (xmax - width) : x}px`;
+      popover.style.top = `${y}px`;
+    }
+
+    function createMenuElements$1(itemList, popover) {
+      const list = itemList.map(function (item, i) {
+        let elem;
+
+        if (typeof item === 'string') {
+          elem = div();
+          elem.innerHTML = item;
+        } else if (typeof item === 'Node') {
+          elem = item;
+        } else {
+          if (typeof item.init === 'function') {
+            item.init();
+          }
+
+          if ("checkbox" === item.type) {
+            elem = createCheckbox("Show all bases", item.value);
+          } else if ("color" === item.type) {
+            const colorPicker = new ColorPicker({
+              parent: popover.parentElement,
+              width: 364,
+              //defaultColor: 'aqua',
+              colorHandler: color => item.click(color)
+            });
+            elem = div();
+
+            if (typeof item.label === 'string') {
+              elem.innerHTML = item.label;
+            }
+
+            const clickHandler = e => {
+              colorPicker.show();
+              hide(popover);
+              e.preventDefault();
+              e.stopPropagation();
+            };
+
+            elem.addEventListener('click', clickHandler);
+            elem.addEventListener('touchend', clickHandler);
+            elem.addEventListener('mouseup', function (e) {
+              e.preventDefault();
+              e.stopPropagation();
+            });
+          } else {
+            elem = div();
+
+            if (typeof item.label === 'string') {
+              elem.innerHTML = item.label;
+            }
+          }
+
+          if (item.click && "color" !== item.type) {
+            elem.addEventListener('click', handleClick);
+            elem.addEventListener('touchend', handleClick);
+            elem.addEventListener('mouseup', function (e) {
+              e.preventDefault();
+              e.stopPropagation();
+            }); // eslint-disable-next-line no-inner-declarations
+
+            function handleClick(e) {
+              item.click();
+              hide(popover);
+              e.preventDefault();
+              e.stopPropagation();
+            }
+          }
+        }
+
+        return {
+          object: elem,
+          init: item.init
+        };
+      });
+      return list;
+    }
+
+    function embedCSS$1() {
+      var css = '.igv-ui-popover {\n  cursor: default;\n  position: absolute;\n  z-index: 2048;\n  border-color: #7F7F7F;\n  border-radius: 4px;\n  border-style: solid;\n  border-width: 1px;\n  font-family: \"Open Sans\", sans-serif;\n  font-size: small;\n  background-color: white; }\n  .igv-ui-popover > div:first-child {\n    display: flex;\n    flex-direction: row;\n    flex-wrap: nowrap;\n    justify-content: space-between;\n    align-items: center;\n    width: 100%;\n    height: 24px;\n    cursor: move;\n    border-top-left-radius: 4px;\n    border-top-right-radius: 4px;\n    border-bottom-color: #7F7F7F;\n    border-bottom-style: solid;\n    border-bottom-width: thin;\n    background-color: #eee; }\n    .igv-ui-popover > div:first-child > div:first-child {\n      margin-left: 4px; }\n    .igv-ui-popover > div:first-child > div:last-child {\n      margin-right: 4px;\n      height: 12px;\n      width: 12px;\n      color: #7F7F7F; }\n    .igv-ui-popover > div:first-child > div:last-child:hover {\n      cursor: pointer;\n      color: #444; }\n  .igv-ui-popover > div:last-child {\n    overflow-y: auto;\n    overflow-x: hidden;\n    max-height: 400px;\n    max-width: 1500px;\n    background-color: white; }\n    .igv-ui-popover > div:last-child > div {\n      -webkit-user-select: all;\n      /* Chrome/Safari */\n      -moz-user-select: all;\n      /* Firefox */\n      margin-left: 4px;\n      margin-right: 4px;\n      min-width: 220px;\n      overflow-x: hidden;\n      text-overflow: ellipsis;\n      white-space: nowrap; }\n      .igv-ui-popover > div:last-child > div > span {\n        font-weight: bolder; }\n    .igv-ui-popover > div:last-child hr {\n      width: 100%; }\n\n.igv-ui-alert-dialog-container {\n  box-sizing: content-box;\n  position: absolute;\n  z-index: 2048;\n  top: 50%;\n  left: 50%;\n  width: 400px;\n  height: 200px;\n  border-color: #7F7F7F;\n  border-radius: 4px;\n  border-style: solid;\n  border-width: thin;\n  outline: none;\n  font-family: \"Open Sans\", sans-serif;\n  font-size: 15px;\n  font-weight: 400;\n  background-color: white;\n  display: flex;\n  flex-flow: column;\n  flex-wrap: nowrap;\n  justify-content: space-between;\n  align-items: center; }\n  .igv-ui-alert-dialog-container > div:first-child {\n    display: flex;\n    flex-flow: row;\n    flex-wrap: nowrap;\n    justify-content: flex-start;\n    align-items: center;\n    width: 100%;\n    height: 24px;\n    cursor: move;\n    border-top-left-radius: 4px;\n    border-top-right-radius: 4px;\n    border-bottom-color: #7F7F7F;\n    border-bottom-style: solid;\n    border-bottom-width: thin;\n    background-color: #eee; }\n    .igv-ui-alert-dialog-container > div:first-child div:first-child {\n      padding-left: 8px; }\n  .igv-ui-alert-dialog-container #igv-ui-alert-dialog-body {\n    color: #373737;\n    width: 100%;\n    height: calc(100% - 24px - 64px);\n    overflow-y: scroll; }\n    .igv-ui-alert-dialog-container #igv-ui-alert-dialog-body #igv-ui-alert-dialog-body-copy {\n      cursor: pointer;\n      margin: 16px;\n      width: auto;\n      height: auto;\n      overflow-wrap: break-word;\n      word-break: break-word;\n      background-color: white;\n      border: unset; }\n  .igv-ui-alert-dialog-container > div:last-child {\n    width: 100%;\n    margin-bottom: 10px;\n    background-color: white;\n    display: flex;\n    flex-flow: row;\n    flex-wrap: nowrap;\n    justify-content: center;\n    align-items: center; }\n    .igv-ui-alert-dialog-container > div:last-child div {\n      margin: unset;\n      width: 40px;\n      height: 30px;\n      line-height: 30px;\n      text-align: center;\n      color: white;\n      font-family: \"Open Sans\", sans-serif;\n      font-size: small;\n      font-weight: 400;\n      border-color: #2B81AF;\n      border-style: solid;\n      border-width: thin;\n      border-radius: 4px;\n      background-color: #2B81AF; }\n    .igv-ui-alert-dialog-container > div:last-child div:hover {\n      cursor: pointer;\n      border-color: #25597f;\n      background-color: #25597f; }\n\n.igv-ui-color-swatch {\n  position: relative;\n  box-sizing: content-box;\n  display: flex;\n  flex-flow: row;\n  flex-wrap: wrap;\n  justify-content: center;\n  align-items: center;\n  width: 32px;\n  height: 32px;\n  border-style: solid;\n  border-width: 2px;\n  border-color: white;\n  border-radius: 4px; }\n\n.igv-ui-color-swatch:hover {\n  border-color: dimgray; }\n\n.igv-ui-colorpicker-menu-close-button {\n  display: flex;\n  flex-flow: row;\n  flex-wrap: nowrap;\n  justify-content: flex-end;\n  align-items: center;\n  width: 100%;\n  height: 32px;\n  margin-top: 4px;\n  margin-bottom: 4px;\n  padding-right: 8px; }\n  .igv-ui-colorpicker-menu-close-button i.fa {\n    display: block;\n    margin-left: 4px;\n    margin-right: 4px;\n    color: #5f5f5f; }\n  .igv-ui-colorpicker-menu-close-button i.fa:hover,\n  .igv-ui-colorpicker-menu-close-button i.fa:focus,\n  .igv-ui-colorpicker-menu-close-button i.fa:active {\n    cursor: pointer;\n    color: #0f0f0f; }\n\n.igv-ui-generic-dialog-container {\n  box-sizing: content-box;\n  position: fixed;\n  top: 0;\n  left: 0;\n  width: 300px;\n  height: 200px;\n  border-color: #7F7F7F;\n  border-radius: 4px;\n  border-style: solid;\n  border-width: thin;\n  font-family: \"Open Sans\", sans-serif;\n  font-size: medium;\n  font-weight: 400;\n  z-index: 2048;\n  background-color: white;\n  display: flex;\n  flex-flow: column;\n  flex-wrap: nowrap;\n  justify-content: flex-start;\n  align-items: center; }\n  .igv-ui-generic-dialog-container .igv-ui-generic-dialog-header {\n    display: flex;\n    flex-flow: row;\n    flex-wrap: nowrap;\n    justify-content: flex-end;\n    align-items: center;\n    width: 100%;\n    height: 24px;\n    cursor: move;\n    border-top-left-radius: 4px;\n    border-top-right-radius: 4px;\n    border-bottom-color: #7F7F7F;\n    border-bottom-style: solid;\n    border-bottom-width: thin;\n    background-color: #eee; }\n    .igv-ui-generic-dialog-container .igv-ui-generic-dialog-header div {\n      margin-right: 4px;\n      margin-bottom: 2px;\n      height: 12px;\n      width: 12px;\n      color: #7F7F7F; }\n    .igv-ui-generic-dialog-container .igv-ui-generic-dialog-header div:hover {\n      cursor: pointer;\n      color: #444; }\n  .igv-ui-generic-dialog-container .igv-ui-generic-dialog-one-liner {\n    color: #373737;\n    width: 95%;\n    height: 24px;\n    line-height: 24px;\n    text-align: left;\n    margin-top: 8px;\n    padding-left: 8px;\n    overflow-wrap: break-word;\n    background-color: white; }\n  .igv-ui-generic-dialog-container .igv-ui-generic-dialog-label-input {\n    margin-top: 8px;\n    width: 95%;\n    height: 24px;\n    color: #373737;\n    line-height: 24px;\n    padding-left: 8px;\n    background-color: white;\n    display: flex;\n    flex-flow: row;\n    flex-wrap: nowrap;\n    justify-content: flex-start;\n    align-items: center; }\n    .igv-ui-generic-dialog-container .igv-ui-generic-dialog-label-input div {\n      width: 30%;\n      height: 100%;\n      font-size: 16px;\n      text-align: right;\n      padding-right: 8px;\n      background-color: white; }\n    .igv-ui-generic-dialog-container .igv-ui-generic-dialog-label-input input {\n      display: block;\n      height: 100%;\n      width: 100%;\n      padding-left: 4px;\n      font-family: \"Open Sans\", sans-serif;\n      font-weight: 400;\n      color: #373737;\n      text-align: left;\n      outline: none;\n      border-style: solid;\n      border-width: thin;\n      border-color: #7F7F7F;\n      background-color: white; }\n    .igv-ui-generic-dialog-container .igv-ui-generic-dialog-label-input input {\n      width: 50%;\n      font-size: 16px; }\n  .igv-ui-generic-dialog-container .igv-ui-generic-dialog-input {\n    margin-top: 8px;\n    width: calc(100% - 16px);\n    height: 24px;\n    color: #373737;\n    line-height: 24px;\n    display: flex;\n    flex-flow: row;\n    flex-wrap: nowrap;\n    justify-content: space-around;\n    align-items: center; }\n    .igv-ui-generic-dialog-container .igv-ui-generic-dialog-input input {\n      display: block;\n      height: 100%;\n      width: 100%;\n      padding-left: 4px;\n      font-family: \"Open Sans\", sans-serif;\n      font-weight: 400;\n      color: #373737;\n      text-align: left;\n      outline: none;\n      border-style: solid;\n      border-width: thin;\n      border-color: #7F7F7F;\n      background-color: white; }\n    .igv-ui-generic-dialog-container .igv-ui-generic-dialog-input input {\n      font-size: 16px; }\n  .igv-ui-generic-dialog-container .igv-ui-generic-dialog-ok-cancel {\n    width: 100%;\n    height: 28px;\n    display: flex;\n    flex-flow: row;\n    flex-wrap: nowrap;\n    justify-content: space-around;\n    align-items: center; }\n    .igv-ui-generic-dialog-container .igv-ui-generic-dialog-ok-cancel div {\n      margin-top: 32px;\n      color: white;\n      font-family: \"Open Sans\", sans-serif;\n      font-size: 14px;\n      font-weight: 400;\n      width: 75px;\n      height: 28px;\n      line-height: 28px;\n      text-align: center;\n      border-color: transparent;\n      border-style: solid;\n      border-width: thin;\n      border-radius: 2px; }\n    .igv-ui-generic-dialog-container .igv-ui-generic-dialog-ok-cancel div:first-child {\n      margin-left: 32px;\n      margin-right: 0;\n      background-color: #5ea4e0; }\n    .igv-ui-generic-dialog-container .igv-ui-generic-dialog-ok-cancel div:last-child {\n      margin-left: 0;\n      margin-right: 32px;\n      background-color: #c4c4c4; }\n    .igv-ui-generic-dialog-container .igv-ui-generic-dialog-ok-cancel div:first-child:hover {\n      cursor: pointer;\n      background-color: #3b5c7f; }\n    .igv-ui-generic-dialog-container .igv-ui-generic-dialog-ok-cancel div:last-child:hover {\n      cursor: pointer;\n      background-color: #7f7f7f; }\n  .igv-ui-generic-dialog-container .igv-ui-generic-dialog-ok {\n    width: 100%;\n    height: 36px;\n    margin-top: 32px;\n    display: flex;\n    flex-flow: row;\n    flex-wrap: nowrap;\n    justify-content: space-around;\n    align-items: center; }\n    .igv-ui-generic-dialog-container .igv-ui-generic-dialog-ok div {\n      width: 98px;\n      height: 36px;\n      line-height: 36px;\n      text-align: center;\n      color: white;\n      font-family: \"Open Sans\", sans-serif;\n      font-size: medium;\n      font-weight: 400;\n      border-color: white;\n      border-style: solid;\n      border-width: thin;\n      border-radius: 4px;\n      background-color: #2B81AF; }\n    .igv-ui-generic-dialog-container .igv-ui-generic-dialog-ok div:hover {\n      cursor: pointer;\n      background-color: #25597f; }\n\n.igv-ui-generic-container {\n  box-sizing: content-box;\n  position: absolute;\n  z-index: 2048;\n  background-color: white;\n  cursor: pointer;\n  display: flex;\n  flex-direction: row;\n  flex-wrap: wrap;\n  justify-content: flex-start;\n  align-items: center; }\n  .igv-ui-generic-container div:first-child {\n    cursor: move;\n    display: flex;\n    flex-flow: row;\n    flex-wrap: nowrap;\n    justify-content: flex-end;\n    align-items: center;\n    height: 24px;\n    width: 100%;\n    background-color: #dddddd; }\n    .igv-ui-generic-container div:first-child div {\n      display: block;\n      color: #5f5f5f;\n      cursor: pointer;\n      width: 14px;\n      height: 14px;\n      margin-right: 8px;\n      margin-bottom: 4px; }\n\n.igv-ui-dialog {\n  z-index: 2048;\n  position: fixed;\n  width: fit-content;\n  height: fit-content;\n  display: flex;\n  flex-flow: column;\n  flex-wrap: nowrap;\n  justify-content: flex-start;\n  background-color: white;\n  border-color: #7F7F7F;\n  border-radius: 4px;\n  border-style: solid;\n  border-width: thin;\n  font-family: \"Open Sans\", sans-serif;\n  font-size: medium;\n  font-weight: 400; }\n  .igv-ui-dialog .igv-ui-dialog-header {\n    display: flex;\n    flex-flow: row;\n    flex-wrap: nowrap;\n    justify-content: flex-end;\n    align-items: center;\n    width: 100%;\n    height: 24px;\n    cursor: move;\n    border-top-left-radius: 4px;\n    border-top-right-radius: 4px;\n    border-bottom-color: #7F7F7F;\n    border-bottom-style: solid;\n    border-bottom-width: thin;\n    background-color: #eee; }\n    .igv-ui-dialog .igv-ui-dialog-header div {\n      margin-right: 4px;\n      margin-bottom: 2px;\n      height: 12px;\n      width: 12px;\n      color: #7F7F7F; }\n    .igv-ui-dialog .igv-ui-dialog-header div:hover {\n      cursor: pointer;\n      color: #444; }\n  .igv-ui-dialog .igv-ui-dialog-one-liner {\n    width: 95%;\n    height: 24px;\n    line-height: 24px;\n    text-align: left;\n    margin: 8px;\n    overflow-wrap: break-word;\n    background-color: white;\n    font-weight: bold; }\n  .igv-ui-dialog .igv-ui-dialog-ok-cancel {\n    width: 100%;\n    display: flex;\n    flex-flow: row;\n    flex-wrap: nowrap;\n    justify-content: space-around;\n    align-items: center; }\n    .igv-ui-dialog .igv-ui-dialog-ok-cancel div {\n      margin: 16px;\n      margin-top: 32px;\n      color: white;\n      font-family: \"Open Sans\", sans-serif;\n      font-size: 14px;\n      font-weight: 400;\n      width: 75px;\n      height: 28px;\n      line-height: 28px;\n      text-align: center;\n      border-color: transparent;\n      border-style: solid;\n      border-width: thin;\n      border-radius: 2px; }\n    .igv-ui-dialog .igv-ui-dialog-ok-cancel div:first-child {\n      background-color: #5ea4e0; }\n    .igv-ui-dialog .igv-ui-dialog-ok-cancel div:last-child {\n      background-color: #c4c4c4; }\n    .igv-ui-dialog .igv-ui-dialog-ok-cancel div:first-child:hover {\n      cursor: pointer;\n      background-color: #3b5c7f; }\n    .igv-ui-dialog .igv-ui-dialog-ok-cancel div:last-child:hover {\n      cursor: pointer;\n      background-color: #7f7f7f; }\n  .igv-ui-dialog .igv-ui-dialog-ok {\n    width: 100%;\n    height: 36px;\n    margin-top: 32px;\n    display: flex;\n    flex-flow: row;\n    flex-wrap: nowrap;\n    justify-content: space-around;\n    align-items: center; }\n    .igv-ui-dialog .igv-ui-dialog-ok div {\n      width: 98px;\n      height: 36px;\n      line-height: 36px;\n      text-align: center;\n      color: white;\n      font-family: \"Open Sans\", sans-serif;\n      font-size: medium;\n      font-weight: 400;\n      border-color: white;\n      border-style: solid;\n      border-width: thin;\n      border-radius: 4px;\n      background-color: #2B81AF; }\n    .igv-ui-dialog .igv-ui-dialog-ok div:hover {\n      cursor: pointer;\n      background-color: #25597f; }\n\n.igv-ui-panel, .igv-ui-panel-column, .igv-ui-panel-row {\n  z-index: 2048;\n  background-color: white;\n  font-family: \"Open Sans\", sans-serif;\n  font-size: medium;\n  font-weight: 400;\n  display: flex;\n  justify-content: flex-start;\n  align-items: flex-start; }\n\n.igv-ui-panel-column {\n  display: flex;\n  flex-direction: column; }\n\n.igv-ui-panel-row {\n  display: flex;\n  flex-direction: row; }\n\n.igv-ui-textbox {\n  background-color: white;\n  font-family: \"Open Sans\", sans-serif;\n  font-size: medium;\n  font-weight: 400;\n  display: flex;\n  justify-content: flex-start;\n  align-items: flex-start; }\n\n/*# sourceMappingURL=igv-ui.css.map */\n';
+      var style = document.createElement('style');
+      style.setAttribute('type', 'text/css');
+      style.innerHTML = css;
+      document.head.insertBefore(style, document.head.childNodes[document.head.childNodes.length - 1]);
+    }
+
+    if (typeof document !== 'undefined') {
+      if (!stylesheetExists("igv-ui.css")) {
+        // console.log('igv-ui. will call embedCSS() ...');
+        embedCSS$1(); // console.log('... done.');
+      }
+
+      function stylesheetExists(stylesheetName) {
+        for (let ss of document.styleSheets) {
+          ss = ss.href ? ss.href.replace(/^.*[\\\/]/, '') : '';
+
+          if (ss === stylesheetName) {
+            return true;
+          }
+        }
+
+        return false;
+      }
+    }
+
+    /*
+     * The MIT License (MIT)
+     *
+     * Copyright (c) 2016-2017 The Regents of the University of California
+     * Author: Jim Robinson
+     *
+     * Permission is hereby granted, free of charge, to any person obtaining a copy
+     * of this software and associated documentation files (the "Software"), to deal
+     * in the Software without restriction, including without limitation the rights
+     * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+     * copies of the Software, and to permit persons to whom the Software is
+     * furnished to do so, subject to the following conditions:
+     *
+     * The above copyright notice and this permission notice shall be included in
+     * all copies or substantial portions of the Software.
+     *
+     *
+     * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+     * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+     * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+     * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+     * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+     * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+     * THE SOFTWARE.
+     */
+
+    class DataRangeDialog {
+      constructor($parent, alert) {
+        // dialog container
+        this.$container = $("<div>", {
+          class: 'igv-generic-dialog-container'
+        });
+        $parent.append(this.$container);
+        this.$container.offset({
+          left: 0,
+          top: 0
+        }); // dialog header
+
+        const $header = $("<div>", {
+          class: 'igv-generic-dialog-header'
+        });
+        this.$container.append($header);
+        attachDialogCloseHandlerWithParent$1($header[0], () => {
+          this.$minimum_input.val(undefined);
+          this.$maximum_input.val(undefined);
+          this.$container.offset({
+            left: 0,
+            top: 0
+          });
+          this.$container.hide();
+        }); // minimun
+
+        this.$minimum = $("<div>", {
+          class: 'igv-generic-dialog-label-input'
+        });
+        this.$container.append(this.$minimum);
+        const $mindiv = $('<div>');
+        $mindiv.text('Minimum');
+        this.$minimum.append($mindiv);
+        this.$minimum_input = $("<input>");
+        this.$minimum.append(this.$minimum_input); // maximum
+
+        this.$maximum = $("<div>", {
+          class: 'igv-generic-dialog-label-input'
+        });
+        this.$container.append(this.$maximum);
+        const $maxdiv = $('<div>');
+        $maxdiv.text('Maximum');
+        this.$maximum.append($maxdiv);
+        this.$maximum_input = $("<input>");
+        this.$maximum.append(this.$maximum_input); // ok | cancel
+
+        const $buttons = $("<div>", {
+          class: 'igv-generic-dialog-ok-cancel'
+        });
+        this.$container.append($buttons); // ok
+
+        this.$ok = $("<div>");
+        $buttons.append(this.$ok);
+        this.$ok.text('OK'); // cancel
+
+        this.$cancel = $("<div>");
+        $buttons.append(this.$cancel);
+        this.$cancel.text('Cancel');
+        this.$cancel.on('click', () => {
+          this.$minimum_input.val(undefined);
+          this.$maximum_input.val(undefined);
+          this.$container.offset({
+            left: 0,
+            top: 0
+          });
+          this.$container.hide();
+        }); //this.$container.draggable({ handle:$header.get(0) });
+
+        makeDraggable$1(this.$container.get(0), $header.get(0));
+        this.$container.hide();
+      }
+
+      configure(trackView) {
+        const dataRange = trackView.dataRange();
+        let min;
+        let max;
+
+        if (dataRange) {
+          min = dataRange.min;
+          max = dataRange.max;
+        } else {
+          min = 0;
+          max = 100;
+        }
+
+        this.$minimum_input.val(min);
+        this.$maximum_input.val(max);
+        this.$minimum_input.unbind();
+        this.$minimum_input.on('keyup', e => {
+          if (13 === e.keyCode) {
+            this.processResults(trackView);
+          }
+        });
+        this.$maximum_input.unbind();
+        this.$maximum_input.on('keyup', e => {
+          if (13 === e.keyCode) {
+            this.processResults(trackView);
+          }
+        });
+        this.$ok.unbind();
+        this.$ok.on('click', e => {
+          this.processResults(trackView);
+        });
+      }
+
+      processResults(trackView) {
+        const min = parseFloat(this.$minimum_input.val());
+        const max = parseFloat(this.$maximum_input.val());
+
+        if (isNaN(min) || isNaN(max)) {
+          Alert.presentAlert(new Error('Must input numeric values'), undefined);
+        } else {
+          trackView.setDataRange(min, max);
+        }
+
+        this.$minimum_input.val(undefined);
+        this.$maximum_input.val(undefined);
+        this.$container.offset({
+          left: 0,
+          top: 0
+        });
+        this.$container.hide();
+      }
+
+      present($parent) {
+        const offset_top = $parent.offset().top;
+        const scroll_top = $('body').scrollTop();
+        this.$container.offset({
+          left: $parent.width() - this.$container.width(),
+          top: offset_top + scroll_top
+        });
+        this.$container.show();
+      }
+
+    }
+
+    /*
+     * The MIT License (MIT)
+     *
+     * Copyright (c) 2014 Broad Institute
+     *
+     * Permission is hereby granted, free of charge, to any person obtaining a copy
+     * of ctx software and associated documentation files (the "Software"), to deal
+     * in the Software without restriction, including without limitation the rights
+     * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+     * copies of the Software, and to permit persons to whom the Software is
+     * furnished to do so, subject to the following conditions:
+     *
+     * The above copyright notice and ctx permission notice shall be included in
+     * all copies or substantial portions of the Software.
+     *
+     *
+     * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+     * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+     * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+     * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+     * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+     * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+     * THE SOFTWARE.
+     */
+
+    const IGVGraphics = {
+      configureHighDPICanvas: function (ctx, w, h) {
+        const scaleFactor = window.devicePixelRatio; // const scaleFactor = 1
+
+        ctx.canvas.style.width = `${w}px`;
+        ctx.canvas.width = Math.floor(scaleFactor * w);
+        ctx.canvas.style.height = `${h}px`;
+        ctx.canvas.height = Math.floor(scaleFactor * h);
+        ctx.scale(scaleFactor, scaleFactor);
+      },
+      setProperties: function (ctx, properties) {
+        for (var key in properties) {
+          if (properties.hasOwnProperty(key)) {
+            var value = properties[key];
+            ctx[key] = value;
+          }
+        }
+      },
+      strokeLine: function (ctx, x1, y1, x2, y2, properties) {
+        x1 = Math.floor(x1) + 0.5;
+        y1 = Math.floor(y1) + 0.5;
+        x2 = Math.floor(x2) + 0.5;
+        y2 = Math.floor(y2) + 0.5;
+
+        if (properties) {
+          ctx.save();
+          IGVGraphics.setProperties(ctx, properties);
+        }
+
+        ctx.beginPath();
+        ctx.moveTo(x1, y1);
+        ctx.lineTo(x2, y2);
+        ctx.stroke();
+        if (properties) ctx.restore();
+      },
+      fillRect: function (ctx, x, y, w, h, properties) {
+        x = Math.round(x);
+        y = Math.round(y);
+
+        if (properties) {
+          ctx.save();
+          IGVGraphics.setProperties(ctx, properties);
+        }
+
+        ctx.fillRect(x, y, w, h);
+        if (properties) ctx.restore();
+      },
+      fillPolygon: function (ctx, x, y, properties) {
+        if (properties) {
+          ctx.save();
+          IGVGraphics.setProperties(ctx, properties);
+        }
+
+        doPath(ctx, x, y);
+        ctx.fill();
+        if (properties) ctx.restore();
+      },
+      strokePolygon: function (ctx, x, y, properties) {
+        if (properties) {
+          ctx.save();
+          IGVGraphics.setProperties(ctx, properties);
+        }
+
+        doPath(ctx, x, y);
+        ctx.stroke();
+        if (properties) ctx.restore();
+      },
+      fillText: function (ctx, text, x, y, properties, transforms) {
+        if (properties || transforms) {
+          ctx.save();
+        }
+
+        if (properties) {
+          IGVGraphics.setProperties(ctx, properties);
+        }
+
+        if (transforms) {
+          // Slow path with context saving and extra translate
+          ctx.translate(x, y);
+
+          for (var transform in transforms) {
+            var value = transforms[transform]; // TODO: Add error checking for robustness
+
+            if (transform === 'translate') {
+              ctx.translate(value['x'], value['y']);
+            }
+
+            if (transform === 'rotate') {
+              ctx.rotate(value['angle'] * Math.PI / 180);
+            }
+          }
+
+          ctx.fillText(text, 0, 0);
+        } else {
+          ctx.fillText(text, x, y);
+        }
+
+        if (properties || transforms) ctx.restore();
+      },
+      strokeText: function (ctx, text, x, y, properties, transforms) {
+        if (properties || transforms) {
+          ctx.save();
+        }
+
+        if (properties) {
+          IGVGraphics.setProperties(ctx, properties);
+        }
+
+        if (transforms) {
+          ctx.translate(x, y);
+
+          for (var transform in transforms) {
+            var value = transforms[transform]; // TODO: Add error checking for robustness
+
+            if (transform === 'translate') {
+              ctx.translate(value['x'], value['y']);
+            }
+
+            if (transform === 'rotate') {
+              ctx.rotate(value['angle'] * Math.PI / 180);
+            }
+          }
+
+          ctx.strokeText(text, 0, 0);
+        } else {
+          ctx.strokeText(text, x, y);
+        }
+
+        if (properties || transforms) ctx.restore();
+      },
+      strokeCircle: function (ctx, x, y, radius, properties) {
+        if (properties) {
+          ctx.save();
+          IGVGraphics.setProperties(ctx, properties);
+        }
+
+        ctx.beginPath();
+        ctx.arc(x, y, radius, 0, 2 * Math.PI);
+        ctx.stroke();
+        if (properties) ctx.restore();
+      },
+      fillCircle: function (ctx, x, y, radius, properties) {
+        if (properties) {
+          ctx.save();
+          IGVGraphics.setProperties(ctx, properties);
+        }
+
+        ctx.beginPath();
+        ctx.arc(x, y, radius, 0, 2 * Math.PI);
+        ctx.fill();
+        if (properties) ctx.restore();
+      },
+      drawArrowhead: function (ctx, x, y, size, lineWidth) {
+        ctx.save();
+
+        if (!size) {
+          size = 5;
+        }
+
+        if (lineWidth) {
+          ctx.lineWidth = lineWidth;
+        }
+
+        ctx.beginPath();
+        ctx.moveTo(x, y - size / 2);
+        ctx.lineTo(x, y + size / 2);
+        ctx.lineTo(x + size, y);
+        ctx.lineTo(x, y - size / 2);
+        ctx.closePath();
+        ctx.fill();
+        ctx.restore();
+      },
+      dashedLine: function (ctx, x1, y1, x2, y2, dashLen, properties = {}) {
+        if (dashLen === undefined) dashLen = 2;
+        ctx.setLineDash([dashLen, dashLen]);
+        IGVGraphics.strokeLine(ctx, x1, y1, x2, y2, properties);
+        ctx.setLineDash([]);
+      },
+      roundRect: function (ctx, x, y, width, height, radius, fill, stroke) {
+        if (typeof stroke == "undefined") {
+          stroke = true;
+        }
+
+        if (typeof radius === "undefined") {
+          radius = 5;
+        }
+
+        ctx.beginPath();
+        ctx.moveTo(x + radius, y);
+        ctx.lineTo(x + width - radius, y);
+        ctx.quadraticCurveTo(x + width, y, x + width, y + radius);
+        ctx.lineTo(x + width, y + height - radius);
+        ctx.quadraticCurveTo(x + width, y + height, x + width - radius, y + height);
+        ctx.lineTo(x + radius, y + height);
+        ctx.quadraticCurveTo(x, y + height, x, y + height - radius);
+        ctx.lineTo(x, y + radius);
+        ctx.quadraticCurveTo(x, y, x + radius, y);
+        ctx.closePath();
+
+        if (stroke) {
+          ctx.stroke();
+        }
+
+        if (fill) {
+          ctx.fill();
+        }
+      },
+      polygon: function (ctx, x, y, fill, stroke) {
+        if (typeof stroke == "undefined") {
+          stroke = true;
+        }
+
+        ctx.beginPath();
+        var len = x.length;
+        ctx.moveTo(x[0], y[0]);
+
+        for (var i = 1; i < len; i++) {
+          ctx.lineTo(x[i], y[i]); // this.moveTo(x[i], y[i]);
+        }
+
+        ctx.closePath();
+
+        if (stroke) {
+          ctx.stroke();
+        }
+
+        if (fill) {
+          ctx.fill();
+        }
+      }
+    };
+
+    function doPath(ctx, x, y) {
+      var i,
+          len = x.length;
+
+      for (i = 0; i < len; i++) {
+        x[i] = Math.round(x[i]);
+        y[i] = Math.round(y[i]);
+      }
+
+      ctx.beginPath();
+      ctx.moveTo(x[0], y[0]);
+
+      for (i = 1; i < len; i++) {
+        ctx.lineTo(x[i], y[i]);
+      }
+
+      ctx.closePath();
+    }
+
+    // eslint-disable-next-line es/no-typed-arrays -- safe
+    var arrayBufferNative = typeof ArrayBuffer !== 'undefined' && typeof DataView !== 'undefined';
+
+    var fails = function (exec) {
+      try {
+        return !!exec();
+      } catch (error) {
+        return true;
+      }
+    };
+
+    var descriptors = !fails(function () {
+      // eslint-disable-next-line es/no-object-defineproperty -- required for testing
+      return Object.defineProperty({}, 1, {
+        get: function () {
+          return 7;
+        }
+      })[1] != 7;
+    });
+
+    var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+
+    function createCommonjsModule(fn) {
+      var module = { exports: {} };
+    	return fn(module, module.exports), module.exports;
+    }
+
+    var check = function (it) {
+      return it && it.Math == Math && it;
+    }; // https://github.com/zloirock/core-js/issues/86#issuecomment-115759028
+
+
+    var global$1 = // eslint-disable-next-line es/no-global-this -- safe
+    check(typeof globalThis == 'object' && globalThis) || check(typeof window == 'object' && window) || // eslint-disable-next-line no-restricted-globals -- safe
+    check(typeof self == 'object' && self) || check(typeof commonjsGlobal == 'object' && commonjsGlobal) || // eslint-disable-next-line no-new-func -- fallback
+    function () {
+      return this;
+    }() || Function('return this')();
+
+    var isObject = function (it) {
+      return typeof it === 'object' ? it !== null : typeof it === 'function';
+    };
+
+    // `RequireObjectCoercible` abstract operation
+    // https://tc39.es/ecma262/#sec-requireobjectcoercible
+    var requireObjectCoercible = function (it) {
+      if (it == undefined) throw TypeError("Can't call method on " + it);
+      return it;
+    };
+
+    // https://tc39.es/ecma262/#sec-toobject
+
+    var toObject = function (argument) {
+      return Object(requireObjectCoercible(argument));
+    };
+
+    var hasOwnProperty = {}.hasOwnProperty;
+
+    var has$1 = Object.hasOwn || function hasOwn(it, key) {
+      return hasOwnProperty.call(toObject(it), key);
+    };
+
+    var document$1 = global$1.document; // typeof document.createElement is 'object' in old IE
+
+    var EXISTS = isObject(document$1) && isObject(document$1.createElement);
+
+    var documentCreateElement = function (it) {
+      return EXISTS ? document$1.createElement(it) : {};
+    };
+
+    var ie8DomDefine = !descriptors && !fails(function () {
+      // eslint-disable-next-line es/no-object-defineproperty -- requied for testing
+      return Object.defineProperty(documentCreateElement('div'), 'a', {
+        get: function () {
+          return 7;
+        }
+      }).a != 7;
+    });
+
+    var anObject = function (it) {
+      if (!isObject(it)) {
+        throw TypeError(String(it) + ' is not an object');
+      }
+
+      return it;
+    };
+
+    // https://tc39.es/ecma262/#sec-toprimitive
+    // instead of the ES6 spec version, we didn't implement @@toPrimitive case
+    // and the second argument - flag - preferred type is a string
+
+    var toPrimitive = function (input, PREFERRED_STRING) {
+      if (!isObject(input)) return input;
+      var fn, val;
+      if (PREFERRED_STRING && typeof (fn = input.toString) == 'function' && !isObject(val = fn.call(input))) return val;
+      if (typeof (fn = input.valueOf) == 'function' && !isObject(val = fn.call(input))) return val;
+      if (!PREFERRED_STRING && typeof (fn = input.toString) == 'function' && !isObject(val = fn.call(input))) return val;
+      throw TypeError("Can't convert object to primitive value");
+    };
+
+    var $defineProperty = Object.defineProperty; // `Object.defineProperty` method
+    // https://tc39.es/ecma262/#sec-object.defineproperty
+
+    var f$4 = descriptors ? $defineProperty : function defineProperty(O, P, Attributes) {
+      anObject(O);
+      P = toPrimitive(P, true);
+      anObject(Attributes);
+      if (ie8DomDefine) try {
+        return $defineProperty(O, P, Attributes);
+      } catch (error) {
+        /* empty */
+      }
+      if ('get' in Attributes || 'set' in Attributes) throw TypeError('Accessors not supported');
+      if ('value' in Attributes) O[P] = Attributes.value;
+      return O;
+    };
+    var objectDefineProperty = {
+      f: f$4
+    };
+
+    var createPropertyDescriptor = function (bitmap, value) {
+      return {
+        enumerable: !(bitmap & 1),
+        configurable: !(bitmap & 2),
+        writable: !(bitmap & 4),
+        value: value
+      };
+    };
+
+    var createNonEnumerableProperty = descriptors ? function (object, key, value) {
+      return objectDefineProperty.f(object, key, createPropertyDescriptor(1, value));
+    } : function (object, key, value) {
+      object[key] = value;
+      return object;
+    };
+
+    var setGlobal = function (key, value) {
+      try {
+        createNonEnumerableProperty(global$1, key, value);
+      } catch (error) {
+        global$1[key] = value;
+      }
+
+      return value;
+    };
+
+    var SHARED = '__core-js_shared__';
+    var store$1 = global$1[SHARED] || setGlobal(SHARED, {});
+    var sharedStore = store$1;
+
+    var shared = createCommonjsModule(function (module) {
+      (module.exports = function (key, value) {
+        return sharedStore[key] || (sharedStore[key] = value !== undefined ? value : {});
+      })('versions', []).push({
+        version: '3.15.2',
+        mode: 'global',
+        copyright: '© 2021 Denis Pushkarev (zloirock.ru)'
+      });
+    });
+
+    var id = 0;
+    var postfix = Math.random();
+
+    var uid = function (key) {
+      return 'Symbol(' + String(key === undefined ? '' : key) + ')_' + (++id + postfix).toString(36);
+    };
+
+    var path = global$1;
+
+    var aFunction$1 = function (variable) {
+      return typeof variable == 'function' ? variable : undefined;
+    };
+
+    var getBuiltIn = function (namespace, method) {
+      return arguments.length < 2 ? aFunction$1(path[namespace]) || aFunction$1(global$1[namespace]) : path[namespace] && path[namespace][method] || global$1[namespace] && global$1[namespace][method];
+    };
+
+    var engineUserAgent = getBuiltIn('navigator', 'userAgent') || '';
+
+    var process$2 = global$1.process;
+    var versions = process$2 && process$2.versions;
+    var v8 = versions && versions.v8;
+    var match, version$1;
+
+    if (v8) {
+      match = v8.split('.');
+      version$1 = match[0] < 4 ? 1 : match[0] + match[1];
+    } else if (engineUserAgent) {
+      match = engineUserAgent.match(/Edge\/(\d+)/);
+
+      if (!match || match[1] >= 74) {
+        match = engineUserAgent.match(/Chrome\/(\d+)/);
+        if (match) version$1 = match[1];
+      }
+    }
+
+    var engineV8Version = version$1 && +version$1;
+
+    /* eslint-disable es/no-symbol -- required for testing */
+
+    var nativeSymbol = !!Object.getOwnPropertySymbols && !fails(function () {
+      var symbol = Symbol(); // Chrome 38 Symbol has incorrect toString conversion
+      // `get-own-property-symbols` polyfill symbols converted to object are not Symbol instances
+
+      return !String(symbol) || !(Object(symbol) instanceof Symbol) || // Chrome 38-40 symbols are not inherited from DOM collections prototypes to instances
+      !Symbol.sham && engineV8Version && engineV8Version < 41;
+    });
+
+    /* eslint-disable es/no-symbol -- required for testing */
+    var useSymbolAsUid = nativeSymbol && !Symbol.sham && typeof Symbol.iterator == 'symbol';
+
+    var WellKnownSymbolsStore = shared('wks');
+    var Symbol$1 = global$1.Symbol;
+    var createWellKnownSymbol = useSymbolAsUid ? Symbol$1 : Symbol$1 && Symbol$1.withoutSetter || uid;
+
+    var wellKnownSymbol = function (name) {
+      if (!has$1(WellKnownSymbolsStore, name) || !(nativeSymbol || typeof WellKnownSymbolsStore[name] == 'string')) {
+        if (nativeSymbol && has$1(Symbol$1, name)) {
+          WellKnownSymbolsStore[name] = Symbol$1[name];
+        } else {
+          WellKnownSymbolsStore[name] = createWellKnownSymbol('Symbol.' + name);
+        }
+      }
+
+      return WellKnownSymbolsStore[name];
+    };
+
+    var TO_STRING_TAG$2 = wellKnownSymbol('toStringTag');
+    var test = {};
+    test[TO_STRING_TAG$2] = 'z';
+    var toStringTagSupport = String(test) === '[object z]';
+
+    var toString = {}.toString;
+
+    var classofRaw = function (it) {
+      return toString.call(it).slice(8, -1);
+    };
+
+    var TO_STRING_TAG$1 = wellKnownSymbol('toStringTag'); // ES3 wrong here
+
+    var CORRECT_ARGUMENTS = classofRaw(function () {
+      return arguments;
+    }()) == 'Arguments'; // fallback for IE11 Script Access Denied error
+
+    var tryGet = function (it, key) {
+      try {
+        return it[key];
+      } catch (error) {
+        /* empty */
+      }
+    }; // getting tag from ES6+ `Object.prototype.toString`
+
+
+    var classof = toStringTagSupport ? classofRaw : function (it) {
+      var O, tag, result;
+      return it === undefined ? 'Undefined' : it === null ? 'Null' // @@toStringTag case
+      : typeof (tag = tryGet(O = Object(it), TO_STRING_TAG$1)) == 'string' ? tag // builtinTag case
+      : CORRECT_ARGUMENTS ? classofRaw(O) // ES3 arguments fallback
+      : (result = classofRaw(O)) == 'Object' && typeof O.callee == 'function' ? 'Arguments' : result;
+    };
+
+    var functionToString = Function.toString; // this helper broken in `core-js@3.4.1-3.4.4`, so we can't use `shared` helper
+
+    if (typeof sharedStore.inspectSource != 'function') {
+      sharedStore.inspectSource = function (it) {
+        return functionToString.call(it);
+      };
+    }
+
+    var inspectSource = sharedStore.inspectSource;
+
+    var WeakMap$1 = global$1.WeakMap;
+    var nativeWeakMap = typeof WeakMap$1 === 'function' && /native code/.test(inspectSource(WeakMap$1));
+
+    var keys = shared('keys');
+
+    var sharedKey = function (key) {
+      return keys[key] || (keys[key] = uid(key));
+    };
+
+    var hiddenKeys$1 = {};
+
+    var OBJECT_ALREADY_INITIALIZED = 'Object already initialized';
+    var WeakMap = global$1.WeakMap;
+    var set$1, get, has;
+
+    var enforce = function (it) {
+      return has(it) ? get(it) : set$1(it, {});
+    };
+
+    var getterFor = function (TYPE) {
+      return function (it) {
+        var state;
+
+        if (!isObject(it) || (state = get(it)).type !== TYPE) {
+          throw TypeError('Incompatible receiver, ' + TYPE + ' required');
+        }
+
+        return state;
+      };
+    };
+
+    if (nativeWeakMap || sharedStore.state) {
+      var store = sharedStore.state || (sharedStore.state = new WeakMap());
+      var wmget = store.get;
+      var wmhas = store.has;
+      var wmset = store.set;
+
+      set$1 = function (it, metadata) {
+        if (wmhas.call(store, it)) throw new TypeError(OBJECT_ALREADY_INITIALIZED);
+        metadata.facade = it;
+        wmset.call(store, it, metadata);
+        return metadata;
+      };
+
+      get = function (it) {
+        return wmget.call(store, it) || {};
+      };
+
+      has = function (it) {
+        return wmhas.call(store, it);
+      };
+    } else {
+      var STATE = sharedKey('state');
+      hiddenKeys$1[STATE] = true;
+
+      set$1 = function (it, metadata) {
+        if (has$1(it, STATE)) throw new TypeError(OBJECT_ALREADY_INITIALIZED);
+        metadata.facade = it;
+        createNonEnumerableProperty(it, STATE, metadata);
+        return metadata;
+      };
+
+      get = function (it) {
+        return has$1(it, STATE) ? it[STATE] : {};
+      };
+
+      has = function (it) {
+        return has$1(it, STATE);
+      };
+    }
+
+    var internalState = {
+      set: set$1,
+      get: get,
+      has: has,
+      enforce: enforce,
+      getterFor: getterFor
+    };
+
+    var redefine = createCommonjsModule(function (module) {
+      var getInternalState = internalState.get;
+      var enforceInternalState = internalState.enforce;
+      var TEMPLATE = String(String).split('String');
+      (module.exports = function (O, key, value, options) {
+        var unsafe = options ? !!options.unsafe : false;
+        var simple = options ? !!options.enumerable : false;
+        var noTargetGet = options ? !!options.noTargetGet : false;
+        var state;
+
+        if (typeof value == 'function') {
+          if (typeof key == 'string' && !has$1(value, 'name')) {
+            createNonEnumerableProperty(value, 'name', key);
+          }
+
+          state = enforceInternalState(value);
+
+          if (!state.source) {
+            state.source = TEMPLATE.join(typeof key == 'string' ? key : '');
+          }
+        }
+
+        if (O === global$1) {
+          if (simple) O[key] = value;else setGlobal(key, value);
+          return;
+        } else if (!unsafe) {
+          delete O[key];
+        } else if (!noTargetGet && O[key]) {
+          simple = true;
+        }
+
+        if (simple) O[key] = value;else createNonEnumerableProperty(O, key, value); // add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative
+      })(Function.prototype, 'toString', function toString() {
+        return typeof this == 'function' && getInternalState(this).source || inspectSource(this);
+      });
+    });
+
+    var correctPrototypeGetter = !fails(function () {
+      function F() {
+        /* empty */
+      }
+
+      F.prototype.constructor = null; // eslint-disable-next-line es/no-object-getprototypeof -- required for testing
+
+      return Object.getPrototypeOf(new F()) !== F.prototype;
+    });
+
+    var IE_PROTO = sharedKey('IE_PROTO');
+    var ObjectPrototype$1 = Object.prototype; // `Object.getPrototypeOf` method
+    // https://tc39.es/ecma262/#sec-object.getprototypeof
+    // eslint-disable-next-line es/no-object-getprototypeof -- safe
+
+    var objectGetPrototypeOf = correctPrototypeGetter ? Object.getPrototypeOf : function (O) {
+      O = toObject(O);
+      if (has$1(O, IE_PROTO)) return O[IE_PROTO];
+
+      if (typeof O.constructor == 'function' && O instanceof O.constructor) {
+        return O.constructor.prototype;
+      }
+
+      return O instanceof Object ? ObjectPrototype$1 : null;
+    };
+
+    var aPossiblePrototype = function (it) {
+      if (!isObject(it) && it !== null) {
+        throw TypeError("Can't set " + String(it) + ' as a prototype');
+      }
+
+      return it;
+    };
+
+    /* eslint-disable no-proto -- safe */
+    // https://tc39.es/ecma262/#sec-object.setprototypeof
+    // Works with __proto__ only. Old v8 can't work with null proto objects.
+    // eslint-disable-next-line es/no-object-setprototypeof -- safe
+
+    var objectSetPrototypeOf = Object.setPrototypeOf || ('__proto__' in {} ? function () {
+      var CORRECT_SETTER = false;
+      var test = {};
+      var setter;
+
+      try {
+        // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
+        setter = Object.getOwnPropertyDescriptor(Object.prototype, '__proto__').set;
+        setter.call(test, []);
+        CORRECT_SETTER = test instanceof Array;
+      } catch (error) {
+        /* empty */
+      }
+
+      return function setPrototypeOf(O, proto) {
+        anObject(O);
+        aPossiblePrototype(proto);
+        if (CORRECT_SETTER) setter.call(O, proto);else O.__proto__ = proto;
+        return O;
+      };
+    }() : undefined);
+
+    var defineProperty = objectDefineProperty.f;
+    var Int8Array = global$1.Int8Array;
+    var Int8ArrayPrototype = Int8Array && Int8Array.prototype;
+    var Uint8ClampedArray = global$1.Uint8ClampedArray;
+    var Uint8ClampedArrayPrototype = Uint8ClampedArray && Uint8ClampedArray.prototype;
+    var TypedArray = Int8Array && objectGetPrototypeOf(Int8Array);
+    var TypedArrayPrototype = Int8ArrayPrototype && objectGetPrototypeOf(Int8ArrayPrototype);
+    var ObjectPrototype = Object.prototype;
+    var isPrototypeOf = ObjectPrototype.isPrototypeOf;
+    var TO_STRING_TAG = wellKnownSymbol('toStringTag');
+    var TYPED_ARRAY_TAG = uid('TYPED_ARRAY_TAG'); // Fixing native typed arrays in Opera Presto crashes the browser, see #595
+
+    var NATIVE_ARRAY_BUFFER_VIEWS = arrayBufferNative && !!objectSetPrototypeOf && classof(global$1.opera) !== 'Opera';
+    var TYPED_ARRAY_TAG_REQIRED = false;
+    var NAME;
+    var TypedArrayConstructorsList = {
+      Int8Array: 1,
+      Uint8Array: 1,
+      Uint8ClampedArray: 1,
+      Int16Array: 2,
+      Uint16Array: 2,
+      Int32Array: 4,
+      Uint32Array: 4,
+      Float32Array: 4,
+      Float64Array: 8
+    };
+    var BigIntArrayConstructorsList = {
+      BigInt64Array: 8,
+      BigUint64Array: 8
+    };
+
+    var isView = function isView(it) {
+      if (!isObject(it)) return false;
+      var klass = classof(it);
+      return klass === 'DataView' || has$1(TypedArrayConstructorsList, klass) || has$1(BigIntArrayConstructorsList, klass);
+    };
+
+    var isTypedArray = function (it) {
+      if (!isObject(it)) return false;
+      var klass = classof(it);
+      return has$1(TypedArrayConstructorsList, klass) || has$1(BigIntArrayConstructorsList, klass);
+    };
+
+    var aTypedArray$1 = function (it) {
+      if (isTypedArray(it)) return it;
+      throw TypeError('Target is not a typed array');
+    };
+
+    var aTypedArrayConstructor = function (C) {
+      if (objectSetPrototypeOf) {
+        if (isPrototypeOf.call(TypedArray, C)) return C;
+      } else for (var ARRAY in TypedArrayConstructorsList) if (has$1(TypedArrayConstructorsList, NAME)) {
+        var TypedArrayConstructor = global$1[ARRAY];
+
+        if (TypedArrayConstructor && (C === TypedArrayConstructor || isPrototypeOf.call(TypedArrayConstructor, C))) {
+          return C;
+        }
+      }
+
+      throw TypeError('Target is not a typed array constructor');
+    };
+
+    var exportTypedArrayMethod$1 = function (KEY, property, forced) {
+      if (!descriptors) return;
+      if (forced) for (var ARRAY in TypedArrayConstructorsList) {
+        var TypedArrayConstructor = global$1[ARRAY];
+        if (TypedArrayConstructor && has$1(TypedArrayConstructor.prototype, KEY)) try {
+          delete TypedArrayConstructor.prototype[KEY];
+        } catch (error) {
+          /* empty */
+        }
+      }
+
+      if (!TypedArrayPrototype[KEY] || forced) {
+        redefine(TypedArrayPrototype, KEY, forced ? property : NATIVE_ARRAY_BUFFER_VIEWS && Int8ArrayPrototype[KEY] || property);
+      }
+    };
+
+    var exportTypedArrayStaticMethod = function (KEY, property, forced) {
+      var ARRAY, TypedArrayConstructor;
+      if (!descriptors) return;
+
+      if (objectSetPrototypeOf) {
+        if (forced) for (ARRAY in TypedArrayConstructorsList) {
+          TypedArrayConstructor = global$1[ARRAY];
+          if (TypedArrayConstructor && has$1(TypedArrayConstructor, KEY)) try {
+            delete TypedArrayConstructor[KEY];
+          } catch (error) {
+            /* empty */
+          }
+        }
+
+        if (!TypedArray[KEY] || forced) {
+          // V8 ~ Chrome 49-50 `%TypedArray%` methods are non-writable non-configurable
+          try {
+            return redefine(TypedArray, KEY, forced ? property : NATIVE_ARRAY_BUFFER_VIEWS && TypedArray[KEY] || property);
+          } catch (error) {
+            /* empty */
+          }
+        } else return;
+      }
+
+      for (ARRAY in TypedArrayConstructorsList) {
+        TypedArrayConstructor = global$1[ARRAY];
+
+        if (TypedArrayConstructor && (!TypedArrayConstructor[KEY] || forced)) {
+          redefine(TypedArrayConstructor, KEY, property);
+        }
+      }
+    };
+
+    for (NAME in TypedArrayConstructorsList) {
+      if (!global$1[NAME]) NATIVE_ARRAY_BUFFER_VIEWS = false;
+    } // WebKit bug - typed arrays constructors prototype is Object.prototype
+
+
+    if (!NATIVE_ARRAY_BUFFER_VIEWS || typeof TypedArray != 'function' || TypedArray === Function.prototype) {
+      // eslint-disable-next-line no-shadow -- safe
+      TypedArray = function TypedArray() {
+        throw TypeError('Incorrect invocation');
+      };
+
+      if (NATIVE_ARRAY_BUFFER_VIEWS) for (NAME in TypedArrayConstructorsList) {
+        if (global$1[NAME]) objectSetPrototypeOf(global$1[NAME], TypedArray);
+      }
+    }
+
+    if (!NATIVE_ARRAY_BUFFER_VIEWS || !TypedArrayPrototype || TypedArrayPrototype === ObjectPrototype) {
+      TypedArrayPrototype = TypedArray.prototype;
+      if (NATIVE_ARRAY_BUFFER_VIEWS) for (NAME in TypedArrayConstructorsList) {
+        if (global$1[NAME]) objectSetPrototypeOf(global$1[NAME].prototype, TypedArrayPrototype);
+      }
+    } // WebKit bug - one more object in Uint8ClampedArray prototype chain
+
+
+    if (NATIVE_ARRAY_BUFFER_VIEWS && objectGetPrototypeOf(Uint8ClampedArrayPrototype) !== TypedArrayPrototype) {
+      objectSetPrototypeOf(Uint8ClampedArrayPrototype, TypedArrayPrototype);
+    }
+
+    if (descriptors && !has$1(TypedArrayPrototype, TO_STRING_TAG)) {
+      TYPED_ARRAY_TAG_REQIRED = true;
+      defineProperty(TypedArrayPrototype, TO_STRING_TAG, {
+        get: function () {
+          return isObject(this) ? this[TYPED_ARRAY_TAG] : undefined;
+        }
+      });
+
+      for (NAME in TypedArrayConstructorsList) if (global$1[NAME]) {
+        createNonEnumerableProperty(global$1[NAME], TYPED_ARRAY_TAG, NAME);
+      }
+    }
+
+    var arrayBufferViewCore = {
+      NATIVE_ARRAY_BUFFER_VIEWS: NATIVE_ARRAY_BUFFER_VIEWS,
+      TYPED_ARRAY_TAG: TYPED_ARRAY_TAG_REQIRED && TYPED_ARRAY_TAG,
+      aTypedArray: aTypedArray$1,
+      aTypedArrayConstructor: aTypedArrayConstructor,
+      exportTypedArrayMethod: exportTypedArrayMethod$1,
+      exportTypedArrayStaticMethod: exportTypedArrayStaticMethod,
+      isView: isView,
+      isTypedArray: isTypedArray,
+      TypedArray: TypedArray,
+      TypedArrayPrototype: TypedArrayPrototype
+    };
+
+    var aFunction = function (it) {
+      if (typeof it != 'function') {
+        throw TypeError(String(it) + ' is not a function');
+      }
+
+      return it;
+    };
+
+    var ceil = Math.ceil;
+    var floor$1 = Math.floor; // `ToInteger` abstract operation
+    // https://tc39.es/ecma262/#sec-tointeger
+
+    var toInteger = function (argument) {
+      return isNaN(argument = +argument) ? 0 : (argument > 0 ? floor$1 : ceil)(argument);
+    };
+
+    var min$1 = Math.min; // `ToLength` abstract operation
+    // https://tc39.es/ecma262/#sec-tolength
+
+    var toLength = function (argument) {
+      return argument > 0 ? min$1(toInteger(argument), 0x1FFFFFFFFFFFFF) : 0; // 2 ** 53 - 1 == 9007199254740991
+    };
+
+    // TODO: use something more complex like timsort?
+    var floor = Math.floor;
+
+    var mergeSort = function (array, comparefn) {
+      var length = array.length;
+      var middle = floor(length / 2);
+      return length < 8 ? insertionSort(array, comparefn) : merge(mergeSort(array.slice(0, middle), comparefn), mergeSort(array.slice(middle), comparefn), comparefn);
+    };
+
+    var insertionSort = function (array, comparefn) {
+      var length = array.length;
+      var i = 1;
+      var element, j;
+
+      while (i < length) {
+        j = i;
+        element = array[i];
+
+        while (j && comparefn(array[j - 1], element) > 0) {
+          array[j] = array[--j];
+        }
+
+        if (j !== i++) array[j] = element;
+      }
+
+      return array;
+    };
+
+    var merge = function (left, right, comparefn) {
+      var llength = left.length;
+      var rlength = right.length;
+      var lindex = 0;
+      var rindex = 0;
+      var result = [];
+
+      while (lindex < llength || rindex < rlength) {
+        if (lindex < llength && rindex < rlength) {
+          result.push(comparefn(left[lindex], right[rindex]) <= 0 ? left[lindex++] : right[rindex++]);
+        } else {
+          result.push(lindex < llength ? left[lindex++] : right[rindex++]);
+        }
+      }
+
+      return result;
+    };
+
+    var arraySort = mergeSort;
+
+    var firefox = engineUserAgent.match(/firefox\/(\d+)/i);
+    var engineFfVersion = !!firefox && +firefox[1];
+
+    var engineIsIeOrEdge = /MSIE|Trident/.test(engineUserAgent);
+
+    var webkit = engineUserAgent.match(/AppleWebKit\/(\d+)\./);
+    var engineWebkitVersion = !!webkit && +webkit[1];
+
+    var aTypedArray = arrayBufferViewCore.aTypedArray;
+    var exportTypedArrayMethod = arrayBufferViewCore.exportTypedArrayMethod;
+    var Uint16Array$1 = global$1.Uint16Array;
+    var nativeSort = Uint16Array$1 && Uint16Array$1.prototype.sort; // WebKit
+
+    var ACCEPT_INCORRECT_ARGUMENTS = !!nativeSort && !fails(function () {
+      var array = new Uint16Array$1(2);
+      array.sort(null);
+      array.sort({});
+    });
+    var STABLE_SORT = !!nativeSort && !fails(function () {
+      // feature detection can be too slow, so check engines versions
+      if (engineV8Version) return engineV8Version < 74;
+      if (engineFfVersion) return engineFfVersion < 67;
+      if (engineIsIeOrEdge) return true;
+      if (engineWebkitVersion) return engineWebkitVersion < 602;
+      var array = new Uint16Array$1(516);
+      var expected = Array(516);
+      var index, mod;
+
+      for (index = 0; index < 516; index++) {
+        mod = index % 4;
+        array[index] = 515 - index;
+        expected[index] = index - 2 * mod + 3;
+      }
+
+      array.sort(function (a, b) {
+        return (a / 4 | 0) - (b / 4 | 0);
+      });
+
+      for (index = 0; index < 516; index++) {
+        if (array[index] !== expected[index]) return true;
+      }
+    });
+
+    var getSortCompare = function (comparefn) {
+      return function (x, y) {
+        if (comparefn !== undefined) return +comparefn(x, y) || 0; // eslint-disable-next-line no-self-compare -- NaN check
+
+        if (y !== y) return -1; // eslint-disable-next-line no-self-compare -- NaN check
+
+        if (x !== x) return 1;
+        if (x === 0 && y === 0) return 1 / x > 0 && 1 / y < 0 ? 1 : -1;
+        return x > y;
+      };
+    }; // `%TypedArray%.prototype.sort` method
+    // https://tc39.es/ecma262/#sec-%typedarray%.prototype.sort
+
+
+    exportTypedArrayMethod('sort', function sort(comparefn) {
+      var array = this;
+      if (comparefn !== undefined) aFunction(comparefn);
+      if (STABLE_SORT) return nativeSort.call(array, comparefn);
+      aTypedArray(array);
+      var arrayLength = toLength(array.length);
+      var items = Array(arrayLength);
+      var index;
+
+      for (index = 0; index < arrayLength; index++) {
+        items[index] = array[index];
+      }
+
+      items = arraySort(array, getSortCompare(comparefn));
+
+      for (index = 0; index < arrayLength; index++) {
+        array[index] = items[index];
+      }
+
+      return array;
+    }, !STABLE_SORT || ACCEPT_INCORRECT_ARGUMENTS);
+
+    const Cytoband = function (start, end, name, typestain) {
+      this.start = start;
+      this.end = end;
+      this.name = name;
+      this.stain = 0; // Set the type, either p, n, or c
+
+      if (typestain === 'acen') {
+        this.type = 'c';
+      } else {
+        this.type = typestain.charAt(1);
+
+        if (this.type === 'p') {
+          this.stain = parseInt(typestain.substring(4));
+        }
+      }
+    };
+
+    const GenomicInterval = function (chr, start, end, features) {
+      this.chr = chr;
+      this.start = start;
+      this.end = end;
+      this.features = features;
+    };
+
+    GenomicInterval.prototype.contains = function (chr, start, end) {
+      return this.chr === chr && this.start <= start && this.end >= end;
+    };
+
+    GenomicInterval.prototype.containsRange = function (range) {
+      return this.chr === range.chr && this.start <= range.start && this.end >= range.end;
+    };
+
+    const Chromosome = function (name, order, bpStart, bpLength, rangeLocus) {
+      this.name = name;
+      this.order = order;
+      this.bpStart = bpStart;
+      this.bpLength = bpLength;
+      this.rangeLocus = rangeLocus;
+    };
+
+    /*
+     * The MIT License (MIT)
+     *
+     * Copyright (c) 2014 Broad Institute
+     *
+     * Permission is hereby granted, free of charge, to any person obtaining a copy
+     * of this software and associated documentation files (the "Software"), to deal
+     * in the Software without restriction, including without limitation the rights
+     * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+     * copies of the Software, and to permit persons to whom the Software is
+     * furnished to do so, subject to the following conditions:
+     *
+     * The above copyright notice and this permission notice shall be included in
+     * all copies or substantial portions of the Software.
+     *
+     *
+     * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+     * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+     * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+     * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+     * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+     * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+     * THE SOFTWARE.
+     */
+    /**
+     * Test if the given value is a string or number.  Not using typeof as it fails on boxed primitives.
+     *
+     * @param value
+     * @returns boolean
+     */
+
+
+    function isSimpleType(value) {
+      const simpleTypes = new Set(["boolean", "number", "string", "symbol"]);
+      const valueType = typeof value;
+      return value !== undefined && (simpleTypes.has(valueType) || value.substring || value.toFixed);
+    }
+
+    function buildOptions(config, options) {
+      var defaultOptions = {
+        oauthToken: config.oauthToken,
+        headers: config.headers,
+        withCredentials: config.withCredentials,
+        filename: config.filename
+      };
+      return Object.assign(defaultOptions, options);
+    }
+    /**
+     * isMobile test from http://detectmobilebrowsers.com
+     * TODO -- improve UI design so this isn't neccessary
+     * @returns {boolean}
+     */
+    // igv.isMobile = function () {
+    //
+    //     const a = (navigator.userAgent || navigator.vendor || window.opera);
+    //     return (/(android|bb\d+|meego).+mobile|avantgo|bada\/|blackberry|blazer|compal|elaine|fennec|hiptop|iemobile|ip(hone|od)|iris|kindle|lge |maemo|midp|mmp|mobile.+firefox|netfront|opera m(ob|in)i|palm( os)?|phone|p(ixi|re)\/|plucker|pocket|psp|series(4|6)0|symbian|treo|up\.(browser|link)|vodafone|wap|windows ce|xda|xiino/i.test(a) ||
+    //         /1207|6310|6590|3gso|4thp|50[1-6]i|770s|802s|a wa|abac|ac(er|oo|s\-)|ai(ko|rn)|al(av|ca|co)|amoi|an(ex|ny|yw)|aptu|ar(ch|go)|as(te|us)|attw|au(di|\-m|r |s )|avan|be(ck|ll|nq)|bi(lb|rd)|bl(ac|az)|br(e|v)w|bumb|bw\-(n|u)|c55\/|capi|ccwa|cdm\-|cell|chtm|cldc|cmd\-|co(mp|nd)|craw|da(it|ll|ng)|dbte|dc\-s|devi|dica|dmob|do(c|p)o|ds(12|\-d)|el(49|ai)|em(l2|ul)|er(ic|k0)|esl8|ez([4-7]0|os|wa|ze)|fetc|fly(\-|_)|g1 u|g560|gene|gf\-5|g\-mo|go(\.w|od)|gr(ad|un)|haie|hcit|hd\-(m|p|t)|hei\-|hi(pt|ta)|hp( i|ip)|hs\-c|ht(c(\-| |_|a|g|p|s|t)|tp)|hu(aw|tc)|i\-(20|go|ma)|i230|iac( |\-|\/)|ibro|idea|ig01|ikom|im1k|inno|ipaq|iris|ja(t|v)a|jbro|jemu|jigs|kddi|keji|kgt( |\/)|klon|kpt |kwc\-|kyo(c|k)|le(no|xi)|lg( g|\/(k|l|u)|50|54|\-[a-w])|libw|lynx|m1\-w|m3ga|m50\/|ma(te|ui|xo)|mc(01|21|ca)|m\-cr|me(rc|ri)|mi(o8|oa|ts)|mmef|mo(01|02|bi|de|do|t(\-| |o|v)|zz)|mt(50|p1|v )|mwbp|mywa|n10[0-2]|n20[2-3]|n30(0|2)|n50(0|2|5)|n7(0(0|1)|10)|ne((c|m)\-|on|tf|wf|wg|wt)|nok(6|i)|nzph|o2im|op(ti|wv)|oran|owg1|p800|pan(a|d|t)|pdxg|pg(13|\-([1-8]|c))|phil|pire|pl(ay|uc)|pn\-2|po(ck|rt|se)|prox|psio|pt\-g|qa\-a|qc(07|12|21|32|60|\-[2-7]|i\-)|qtek|r380|r600|raks|rim9|ro(ve|zo)|s55\/|sa(ge|ma|mm|ms|ny|va)|sc(01|h\-|oo|p\-)|sdk\/|se(c(\-|0|1)|47|mc|nd|ri)|sgh\-|shar|sie(\-|m)|sk\-0|sl(45|id)|sm(al|ar|b3|it|t5)|so(ft|ny)|sp(01|h\-|v\-|v )|sy(01|mb)|t2(18|50)|t6(00|10|18)|ta(gt|lk)|tcl\-|tdg\-|tel(i|m)|tim\-|t\-mo|to(pl|sh)|ts(70|m\-|m3|m5)|tx\-9|up(\.b|g1|si)|utst|v400|v750|veri|vi(rg|te)|vk(40|5[0-3]|\-v)|vm40|voda|vulc|vx(52|53|60|61|70|80|81|83|85|98)|w3c(\-| )|webc|whit|wi(g |nc|nw)|wmlb|wonu|x700|yas\-|your|zeto|zte\-/i.test(a.substr(0, 4)))
+    //
+    // }
+
+
+    const doAutoscale = function (features) {
+      var min, max;
+
+      if (features.length > 0) {
+        min = Number.MAX_VALUE;
+        max = -Number.MAX_VALUE;
+        features.forEach(function (f) {
+          if (!Number.isNaN(f.value)) {
+            min = Math.min(min, f.value);
+            max = Math.max(max, f.value);
+          }
+        }); // Insure we have a zero baseline
+
+        if (max > 0) min = Math.min(0, min);
+        if (max < 0) max = 0;
+      } else {
+        // No features -- default
+        min = 0;
+        max = 100;
+      }
+
+      return {
+        min: min,
+        max: max
+      };
+    };
+
+    const validateLocusExtent = function (chromosomeLengthBP, extent, minimumBP) {
+      let ss = extent.start;
+      let ee = extent.end;
+
+      if (undefined === ee) {
+        ss -= minimumBP / 2;
+        ee = ss + minimumBP;
+
+        if (ee > chromosomeLengthBP) {
+          ee = chromosomeLengthBP;
+          ss = ee - minimumBP;
+        } else if (ss < 0) {
+          ss = 0;
+          ee = minimumBP;
+        }
+      } else if (ee - ss < minimumBP) {
+        const center = (ee + ss) / 2;
+
+        if (center - minimumBP / 2 < 0) {
+          ss = 0;
+          ee = ss + minimumBP;
+        } else if (center + minimumBP / 2 > chromosomeLengthBP) {
+          ee = chromosomeLengthBP;
+          ss = ee - minimumBP;
+        } else {
+          ss = center - minimumBP / 2;
+          ee = ss + minimumBP;
+        }
+      }
+
+      extent.start = Math.ceil(ss);
+      extent.end = Math.floor(ee);
+    };
+    /*!
+     * is-number <https://github.com/jonschlinkert/is-number>
+     *
+     * Copyright (c) 2014-present, Jon Schlinkert.
+     * Released under the MIT License.
+     */
+
+
+    const isNumber = function (num) {
+      if (typeof num === 'number') {
+        return num - num === 0;
+      }
+
+      if (typeof num === 'string' && num.trim() !== '') {
+        return Number.isFinite ? Number.isFinite(+num) : isFinite(+num);
+      }
+
+      return false;
+    };
+
+    function inferTrackType(config) {
+      translateDeprecatedTypes(config);
+
+      if (config.type) {
+        return config.type;
+      }
+
+      if (config.format) {
+        const format = config.format.toLowerCase();
+
+        switch (format) {
+          case "bw":
+          case "bigwig":
+          case "wig":
+          case "bedgraph":
+          case "tdf":
+            return "wig";
+
+          case "vcf":
+            return "variant";
+
+          case "seg":
+            return "seg";
+
+          case "mut":
+          case "maf":
+            return "mut";
+
+          case "bam":
+          case "cram":
+            return "alignment";
+
+          case "bedpe":
+          case "bedpe-loop":
+            return "interaction";
+
+          case "bp":
+            return "arc";
+
+          case "gwas":
+            return "gwas";
+
+          case "bed":
+          case "bigbed":
+          case "bb":
+            return "bedtype";
+
+          default:
+            return "annotation";
+        }
+      }
+    }
+
+    function translateDeprecatedTypes(config) {
+      if (config.featureType) {
+        // Translate deprecated "feature" type
+        config.type = config.type || config.featureType;
+        config.featureType = undefined;
+      }
+
+      if ("junctions" === config.type) {
+        config.type = "spliceJunctions";
+      } else if ("bed" === config.type) {
+        config.type = "annotation";
+        config.format = config.format || "bed";
+      } else if ("annotations" === config.type) {
+        config.type = "annotation";
+      } else if ("alignments" === config.type) {
+        config.type = "alignment";
+      } else if ("bam" === config.type) {
+        config.type = "alignment";
+        config.format = "bam";
+      } else if ("vcf" === config.type) {
+        config.type = "variant";
+        config.format = "vcf";
+      } else if ("t2d" === config.type) {
+        config.type = "gwas";
+      } else if ("FusionJuncSpan" === config.type && !config.format) {
+        config.format = "fusionjuncspan";
+      } else if ("aed" === config.type) {
+        config.type = "annotation";
+        config.format = config.format || "aed";
+      }
+    }
+
+    async function getFilename(url) {
+      if (isString$6(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);
+      }
+    }
+
+    const splitLines$2 = splitLines$3;
+    const reservedProperties = new Set(['fastaURL', 'indexURL', 'cytobandURL', 'indexed']);
+
+    class FastaSequence {
+      constructor(reference) {
+        if (typeof reference.fastaURL === 'string' && reference.fastaURL.startsWith('data:')) {
+          this.file = decodeDataUri(reference.fastaURL);
+          this.indexed = false; // dataURI is by definition not indexed
+
+          this.isDataURI = true;
+        } else {
+          this.file = reference.fastaURL;
+          this.indexed = reference.indexed !== false; // Indexed unless it explicitly is not
+
+          if (this.indexed) {
+            this.indexFile = reference.indexURL || reference.indexFile || this.file + ".fai";
+          }
+        }
+
+        this.withCredentials = reference.withCredentials;
+        this.chromosomeNames = [];
+        this.chromosomes = {};
+        this.sequences = {};
+        this.offsets = {}; // Build a track-like config object from the referenceObject
+
+        const config = {};
+
+        for (let key in reference) {
+          if (reference.hasOwnProperty(key) && !reservedProperties.has(key)) {
+            config[key] = reference[key];
+          }
+        }
+
+        this.config = config;
+      }
+
+      async init() {
+        if (this.indexed) {
+          return this.getIndex();
+        } else {
+          return this.loadAll();
+        }
+      }
+
+      async getSequence(chr, start, end) {
+        if (this.indexed) {
+          return this.getSequenceIndexed(chr, start, end);
+        } else {
+          return this.getSequenceNonIndexed(chr, start, end);
+        }
+      }
+
+      async getSequenceIndexed(chr, start, end) {
+        if (!(this.interval && this.interval.contains(chr, start, end))) {
+          // Expand query, to minimum of 50kb
+          let qstart = start;
+          let qend = end;
+
+          if (end - start < 50000) {
+            const w = end - start;
+            const center = Math.round(start + w / 2);
+            qstart = Math.max(0, center - 25000);
+            qend = center + 25000;
+          }
+
+          const seqBytes = await this.readSequence(chr, qstart, qend);
+          this.interval = new GenomicInterval(chr, qstart, qend, seqBytes);
+        }
+
+        const offset = start - this.interval.start;
+        const n = end - start;
+        const seq = this.interval.features ? this.interval.features.substr(offset, n) : null;
+        return seq;
+      }
+
+      async getSequenceNonIndexed(chr, start, end) {
+        if (this.offsets[chr]) {
+          start -= this.offsets[chr];
+          end -= this.offsets[chr];
+        }
+
+        let prefix = "";
+
+        if (start < 0) {
+          for (let i = start; i < Math.min(end, 0); i++) {
+            prefix += "*";
+          }
+        }
+
+        if (end <= 0) {
+          return Promise.resolve(prefix);
+        }
+
+        const seq = this.sequences[chr];
+        const seqEnd = Math.min(end, seq.length);
+        return prefix + seq.substring(start, seqEnd);
+      }
+
+      async getIndex() {
+        if (this.index) {
+          return this.index;
+        } else {
+          const data = await igvxhr.load(this.indexFile, buildOptions(this.config));
+          const lines = splitLines$2(data);
+          const len = lines.length;
+          let lineNo = 0;
+          let order = 0;
+          this.index = {};
+
+          while (lineNo < len) {
+            const tokens = lines[lineNo++].split("\t");
+            const nTokens = tokens.length;
+
+            if (nTokens === 5) {
+              // Parse the index line.
+              const chr = tokens[0];
+              const size = parseInt(tokens[1]);
+              const position = parseInt(tokens[2]);
+              const basesPerLine = parseInt(tokens[3]);
+              const bytesPerLine = parseInt(tokens[4]);
+              const indexEntry = {
+                size: size,
+                position: position,
+                basesPerLine: basesPerLine,
+                bytesPerLine: bytesPerLine
+              };
+              this.chromosomeNames.push(chr);
+              this.index[chr] = indexEntry;
+              this.chromosomes[chr] = new Chromosome(chr, order++, 0, size);
+            }
+          }
+
+          return this.index;
+        }
+      }
+
+      async loadAll() {
+        let data;
+
+        if (this.isDataURI) {
+          data = this.file; // <= Strange convention, revisit.
+        } else {
+          data = await igvxhr.load(this.file, buildOptions(this.config));
+        }
+
+        const lines = splitLines$2(data);
+        const len = lines.length;
+        let lineNo = 0;
+        let currentSeq;
+        let currentRangeLocus;
+        let currentOffset = 0;
+        let order = 0;
+        let nextLine;
+        let currentChr;
+
+        while (lineNo < len) {
+          nextLine = lines[lineNo++].trim();
+
+          if (nextLine.startsWith("#") || nextLine.length === 0) ; else if (nextLine.startsWith(">")) {
+            // Start the next sequence
+            if (currentSeq) {
+              this.chromosomeNames.push(currentChr);
+              this.sequences[currentChr] = currentSeq;
+              this.chromosomes[currentChr] = new Chromosome(currentChr, order++, currentOffset, currentOffset + currentSeq.length, currentRangeLocus);
+            }
+
+            const parts = nextLine.substr(1).split(/\s+/); // Check for samtools style locus string.   This is not perfect, and could fail on weird sequence names
+
+            const nameParts = parts[0].split(':');
+            currentChr = nameParts[0];
+            currentSeq = "";
+            currentOffset = 0;
+            currentRangeLocus = undefined;
+
+            if (nameParts.length > 1 && nameParts[1].indexOf('-') > 0) {
+              const locusParts = nameParts[1].split('-');
+
+              if (locusParts.length === 2 && /^[0-9]+$/.test(locusParts[0]) && /^[0-9]+$/.test(locusParts[1])) ;
+
+              const from = Number.parseInt(locusParts[0]);
+              const to = Number.parseInt(locusParts[1]);
+
+              if (to > from) {
+                currentOffset = from - 1;
+                this.offsets[currentChr] = currentOffset;
+                currentRangeLocus = nameParts[1];
+              }
+            }
+          } else {
+            currentSeq += nextLine;
+          }
+        } // add last seq
+
+
+        if (currentSeq) {
+          this.chromosomeNames.push(currentChr);
+          this.sequences[currentChr] = currentSeq;
+          this.chromosomes[currentChr] = new Chromosome(currentChr, order++, currentOffset, currentOffset + currentSeq.length, currentRangeLocus);
+        }
+      }
+
+      async readSequence(chr, qstart, qend) {
+        // let offset;
+        // let start;
+        // let end;
+        // let basesPerLine;
+        // let nEndBytes;
+        await this.getIndex();
+        const idxEntry = this.index[chr];
+
+        if (!idxEntry) {
+          // Tag interval with null so we don't try again
+          this.interval = new GenomicInterval(chr, qstart, qend, null);
+          return null;
+        } else {
+          const start = Math.max(0, qstart); // qstart should never be < 0
+
+          const end = Math.min(idxEntry.size, qend);
+          const bytesPerLine = idxEntry.bytesPerLine;
+          const basesPerLine = idxEntry.basesPerLine;
+          const position = idxEntry.position;
+          const nEndBytes = bytesPerLine - basesPerLine;
+          const startLine = Math.floor(start / basesPerLine);
+          const endLine = Math.floor(end / basesPerLine);
+          const base0 = startLine * basesPerLine; // Base at beginning of start line
+
+          const offset = start - base0;
+          const startByte = position + startLine * bytesPerLine + offset;
+          const base1 = endLine * basesPerLine;
+          const offset1 = end - base1;
+          const endByte = position + endLine * bytesPerLine + offset1 - 1;
+          const byteCount = endByte - startByte + 1;
+          let allBytes;
+
+          if (byteCount <= 0) {
+            console.error("No sequence for " + chr + ":" + qstart + "-" + qend);
+          } else {
+            allBytes = await igvxhr.load(this.file, buildOptions(this.config, {
+              range: {
+                start: startByte,
+                size: byteCount
+              }
+            }));
+          }
+
+          if (!allBytes) {
+            return null;
+          } else {
+            let nBases,
+                seqBytes = "",
+                srcPos = 0,
+                allBytesLength = allBytes.length;
+
+            if (offset > 0) {
+              nBases = Math.min(end - start, basesPerLine - offset);
+              seqBytes += allBytes.substr(srcPos, nBases);
+              srcPos += nBases + nEndBytes;
+            }
+
+            while (srcPos < allBytesLength) {
+              nBases = Math.min(basesPerLine, allBytesLength - srcPos);
+              seqBytes += allBytes.substr(srcPos, nBases);
+              srcPos += nBases + nEndBytes;
+            }
+
+            return seqBytes;
+          }
+        }
+      }
+
+    }
+
+    function decodeDataUri(dataUri) {
+      const split = dataUri.split(',');
+      const info = split[0].split(':')[1];
+      let dataString = split[1];
+
+      if (info.indexOf('base64') >= 0) {
+        dataString = atob(dataString);
+      } else {
+        dataString = decodeURI(dataString);
+      }
+
+      const bytes = new Uint8Array(dataString.length);
+
+      for (let i = 0; i < dataString.length; i++) {
+        bytes[i] = dataString.charCodeAt(i);
+      }
+
+      const inflate = new Zlib$1.Gunzip(bytes);
+      const plain = inflate.decompress();
+      let s = "";
+      const len = plain.length;
+
+      for (let i = 0; i < len; i++) s += String.fromCharCode(plain[i]);
+
+      return s;
+    }
+
+    const _version = "2.9.3";
+
+    function version() {
+      return _version;
+    }
+
+    const DEFAULT_GENOMES_URL = "https://igv.org/genomes/genomes.json";
+    const BACKUP_GENOMES_URL = "https://s3.amazonaws.com/igv.org.genomes/genomes.json";
+    const splitLines$1 = splitLines$3;
+    const GenomeUtils = {
+      loadGenome: async function (options) {
+        const cytobandUrl = options.cytobandURL;
+        const aliasURL = options.aliasURL;
+        const sequence = new FastaSequence(options);
+        await sequence.init();
+        let cytobands;
+
+        if (cytobandUrl) {
+          cytobands = await loadCytobands(cytobandUrl, sequence.config);
+        }
+
+        let aliases;
+
+        if (aliasURL) {
+          aliases = await loadAliases(aliasURL, sequence.config);
+        }
+
+        return new Genome(options, sequence, cytobands, aliases);
+      },
+      initializeGenomes: async function (config) {
+        if (!GenomeUtils.KNOWN_GENOMES) {
+          const table = {}; // Get default genomes
+
+          if (config.loadDefaultGenomes !== false) {
+            try {
+              const url = DEFAULT_GENOMES_URL + `?randomSeed=${Math.random().toString(36)}&version=${version()}`; // prevent caching
+
+              const jsonArray = await igvxhr.loadJson(url, {
+                timeout: 3000
+              });
+              processJson(jsonArray);
+            } catch (e) {
+              console.error(e);
+              const url = BACKUP_GENOMES_URL + `?randomSeed=${Math.random().toString(36)}&version=${version()}`; // prevent caching
+
+              const jsonArray = await igvxhr.loadJson(url, {});
+              processJson(jsonArray);
+            }
+          } // Add user-defined genomes
+
+
+          const genomeList = config.genomeList || config.genomes;
+
+          if (genomeList) {
+            if (typeof genomeList === 'string') {
+              const jsonArray = await igvxhr.loadJson(genomeList, {});
+              processJson(jsonArray);
+            } else {
+              processJson(genomeList);
+            }
+          }
+
+          GenomeUtils.KNOWN_GENOMES = table;
+
+          function processJson(jsonArray) {
+            jsonArray.forEach(function (json) {
+              table[json.id] = json;
+            });
+            return table;
+          }
+        }
+      },
+      isWholeGenomeView: function (chr) {
+        return 'all' === chr.toLowerCase();
+      },
+      // Expand a genome id to a reference object, if needed
+      expandReference: function (idOrConfig) {
+        // idOrConfig might be json
+        if (isString$6(idOrConfig) && idOrConfig.startsWith("{")) {
+          try {
+            idOrConfig = JSON.parse(idOrConfig);
+          } catch (e) {// Apparently its not json,  could be an ID starting with "{".  Unusual but legal.
+          }
+        }
+
+        let genomeID;
+
+        if (isString$6(idOrConfig)) {
+          genomeID = idOrConfig;
+        } else if (idOrConfig.genome) {
+          genomeID = idOrConfig.genome;
+        } else if (idOrConfig.id !== undefined && idOrConfig.fastaURL === undefined) {
+          // Backward compatibility
+          genomeID = idOrConfig.id;
+        }
+
+        if (genomeID) {
+          const knownGenomes = GenomeUtils.KNOWN_GENOMES;
+          const reference = knownGenomes[genomeID];
+
+          if (!reference) {
+            Alert.presentAlert(new Error(`Unknown genome id: ${genomeID}`), undefined);
+          }
+
+          return reference;
+        } else {
+          return idOrConfig;
+        }
+      }
+    };
+
+    class Genome {
+      constructor(config, sequence, ideograms, aliases) {
+        this.config = config;
+        this.id = config.id;
+        this.sequence = sequence;
+        this.chromosomeNames = sequence.chromosomeNames;
+        this.chromosomes = sequence.chromosomes; // An object (functions as a dictionary)
+
+        this.ideograms = ideograms;
+        this.featureDB = {}; // Hash of name -> feature, used for search function.
+
+        this.wholeGenomeView = config.wholeGenomeView === undefined || config.wholeGenomeView;
+
+        if (this.wholeGenomeView && Object.keys(sequence.chromosomes).length > 1) {
+          constructWG(this, config);
+        } else {
+          this.wgChromosomeNames = sequence.chromosomeNames;
+        }
+        /**
+         * Return the official chromosome name for the (possibly) alias.  Deals with
+         * 1 <-> chr1,  chrM <-> MT,  IV <-> chr4, etc.
+         * @param str
+         */
+
+
+        var chrAliasTable = {},
+            self = this; // The standard mappings
+
+        chrAliasTable["all"] = "all";
+        this.chromosomeNames.forEach(function (name) {
+          var alias = name.startsWith("chr") ? name.substring(3) : "chr" + name;
+          chrAliasTable[alias.toLowerCase()] = name;
+          if (name === "chrM") chrAliasTable["mt"] = "chrM";
+          if (name === "MT") chrAliasTable["chrm"] = "MT";
+          chrAliasTable[name.toLowerCase()] = name;
+        }); // Custom mappings
+
+        if (aliases) {
+          aliases.forEach(function (array) {
+            // Find the official chr name
+            var defName, i;
+
+            for (i = 0; i < array.length; i++) {
+              if (self.chromosomes[array[i]]) {
+                defName = array[i];
+                break;
+              }
+            }
+
+            if (defName) {
+              array.forEach(function (alias) {
+                if (alias !== defName) {
+                  chrAliasTable[alias.toLowerCase()] = defName;
+                  chrAliasTable[alias] = defName; // Should not be needed
+                }
+              });
+            }
+          });
+        }
+
+        this.chrAliasTable = chrAliasTable;
+      }
+
+      showWholeGenomeView() {
+        return this.config.wholeGenomeView !== false;
+      }
+
+      toJSON() {
+        return Object.assign({}, this.config, {
+          tracks: undefined
+        });
+      }
+
+      getInitialLocus() {}
+
+      getHomeChromosomeName() {
+        if (this.showWholeGenomeView() && this.chromosomes.hasOwnProperty("all")) {
+          return "all";
+        } else {
+          const chromosome = this.chromosomes[this.chromosomeNames[0]];
+
+          if (chromosome.rangeLocus) {
+            return chromosome.name + ":" + chromosome.rangeLocus;
+          } else {
+            return this.chromosomeNames[0];
+          }
+        }
+      }
+
+      getChromosomeName(str) {
+        var chr = this.chrAliasTable[str.toLowerCase()];
+        return chr ? chr : str;
+      }
+
+      getChromosome(chr) {
+        chr = this.getChromosomeName(chr);
+        return this.chromosomes[chr];
+      }
+
+      getCytobands(chr) {
+        return this.ideograms ? this.ideograms[chr] : null;
+      }
+
+      getLongestChromosome() {
+        var longestChr,
+            chromosomes = this.chromosomes;
+
+        for (let key in chromosomes) {
+          if (chromosomes.hasOwnProperty(key)) {
+            var chr = chromosomes[key];
+
+            if (longestChr === undefined || chr.bpLength > longestChr.bpLength) {
+              longestChr = chr;
+            }
+          }
+
+          return longestChr;
+        }
+      }
+
+      getChromosomes() {
+        return this.chromosomes;
+      }
+      /**
+       * Return the genome coordinate in kb for the give chromosome and position.
+       * NOTE: This might return undefined if the chr is filtered from whole genome view.
+       */
+
+
+      getGenomeCoordinate(chr, bp) {
+        var offset = this.getCumulativeOffset(chr);
+        if (offset === undefined) return undefined;
+        return offset + bp;
+      }
+      /**
+       * Return the chromosome and coordinate in bp for the given genome coordinate
+       */
+
+
+      getChromosomeCoordinate(genomeCoordinate) {
+        if (this.cumulativeOffsets === undefined) {
+          this.cumulativeOffsets = computeCumulativeOffsets.call(this);
+        }
+
+        let lastChr = undefined;
+        let lastCoord = 0;
+
+        for (let name of this.wgChromosomeNames) {
+          const cumulativeOffset = this.cumulativeOffsets[name];
+
+          if (cumulativeOffset > genomeCoordinate) {
+            const position = genomeCoordinate - lastCoord;
+            return {
+              chr: lastChr,
+              position: position
+            };
+          }
+
+          lastChr = name;
+          lastCoord = cumulativeOffset;
+        } // If we get here off the end
+
+
+        return {
+          chr: this.chromosomeNames[this.chromosomeNames.length - 1],
+          position: 0
+        };
+      }
+
+      /**
+       * Return the offset in genome coordinates (kb) of the start of the given chromosome
+       * NOTE:  This might return undefined if the chromosome is filtered from whole genome view.
+       */
+      getCumulativeOffset(chr) {
+        if (this.cumulativeOffsets === undefined) {
+          this.cumulativeOffsets = computeCumulativeOffsets.call(this);
+        }
+
+        const queryChr = this.getChromosomeName(chr);
+        return this.cumulativeOffsets[queryChr];
+
+        function computeCumulativeOffsets() {
+          let self = this;
+          let acc = {};
+          let offset = 0;
+
+          for (let name of self.wgChromosomeNames) {
+            acc[name] = Math.floor(offset);
+            const chromosome = self.getChromosome(name);
+            offset += chromosome.bpLength;
+          }
+
+          return acc;
+        }
+      }
+      /**
+       * Return the nominal genome length, this is the length of the main chromosomes (no scaffolds, etc).
+       */
+
+
+      getGenomeLength() {
+        let self = this;
+
+        if (!this.bpLength) {
+          let bpLength = 0;
+          self.wgChromosomeNames.forEach(function (cname) {
+            let c = self.chromosomes[cname];
+            bpLength += c.bpLength;
+          });
+          this.bpLength = bpLength;
+        }
+
+        return this.bpLength;
+      }
+
+    }
+
+    function loadCytobands(cytobandUrl, config) {
+      if (cytobandUrl.startsWith("data:")) {
+        var data = decodeDataUri(cytobandUrl);
+        return Promise.resolve(getCytobands(data));
+      } else {
+        return igvxhr.loadString(cytobandUrl, buildOptions(config)).then(function (data) {
+          return getCytobands(data);
+        });
+      }
+
+      function getCytobands(data) {
+        var bands = [],
+            lastChr,
+            n = 0,
+            lines = splitLines$1(data),
+            len = lines.length,
+            cytobands = {};
+
+        for (var i = 0; i < len; i++) {
+          var tokens = lines[i].split("\t");
+          var chr = tokens[0];
+          if (!lastChr) lastChr = chr;
+
+          if (chr !== lastChr) {
+            cytobands[lastChr] = bands;
+            bands = [];
+            lastChr = chr;
+            n = 0;
+          }
+
+          if (tokens.length === 5) {
+            //10	0	3000000	p15.3	gneg
+            var start = parseInt(tokens[1]);
+            var end = parseInt(tokens[2]);
+            var name = tokens[3];
+            var stain = tokens[4];
+            bands[n++] = new Cytoband(start, end, name, stain);
+          }
+        }
+
+        return cytobands;
+      }
+
+      function decodeDataUri(dataUri) {
+        let plain;
+
+        if (dataUri.startsWith("data:application/gzip;base64")) {
+          plain = decodeDataURI$1(dataUri);
+        } else {
+          let bytes,
+              split = dataUri.split(','),
+              info = split[0].split(':')[1],
+              dataString = split[1];
+
+          if (info.indexOf('base64') >= 0) {
+            dataString = atob(dataString);
+          } else {
+            dataString = decodeURI(dataString);
+          }
+
+          bytes = new Uint8Array(dataString.length);
+
+          for (let i = 0; i < dataString.length; i++) {
+            bytes[i] = dataString.charCodeAt(i);
+          }
+
+          var inflate = new Zlib$1.Gunzip(bytes);
+          plain = inflate.decompress();
+        }
+
+        let s = "";
+        const len = plain.length;
+
+        for (let i = 0; i < len; i++) {
+          s += String.fromCharCode(plain[i]);
+        }
+
+        return s;
+      }
+    }
+
+    function loadAliases(aliasURL, config) {
+      return igvxhr.loadString(aliasURL, buildOptions(config)).then(function (data) {
+        var lines = splitLines$1(data),
+            aliases = [];
+        lines.forEach(function (line) {
+          if (!line.startsWith("#") && line.length > 0) aliases.push(line.split("\t"));
+        });
+        return aliases;
+      });
+    }
+
+    function constructWG(genome, config) {
+      let wgChromosomes;
+
+      if (config.chromosomeOrder) {
+        genome.wgChromosomeNames = config.chromosomeOrder.split(',').map(nm => nm.trim());
+        wgChromosomes = genome.wgChromosomeNames.map(nm => genome.chromosomes[nm]).filter(chr => chr !== undefined);
+      } else {
+        // Trim small chromosomes.
+        const lengths = Object.keys(genome.chromosomes).map(key => genome.chromosomes[key].bpLength);
+        const median = lengths.reduce((a, b) => Math.max(a, b));
+        const threshold = median / 50;
+        wgChromosomes = Object.values(genome.chromosomes).filter(chr => chr.bpLength > threshold); // Sort chromosomes.  First segregate numeric and alpha names, sort numeric, leave alpha as is
+
+        const numericChromosomes = wgChromosomes.filter(chr => isDigit(chr.name.replace('chr', '')));
+        const alphaChromosomes = wgChromosomes.filter(chr => !isDigit(chr.name.replace('chr', '')));
+        numericChromosomes.sort((a, b) => Number.parseInt(a.name.replace('chr', '')) - Number.parseInt(b.name.replace('chr', '')));
+        const wgChromosomeNames = numericChromosomes.map(chr => chr.name);
+
+        for (let chr of alphaChromosomes) {
+          wgChromosomeNames.push(chr.name);
+        }
+
+        genome.wgChromosomeNames = wgChromosomeNames;
+      } // Compute psuedo-chromosome "all"
+
+
+      const l = wgChromosomes.reduce((accumulator, currentValue) => accumulator += currentValue.bpLength, 0);
+      genome.chromosomes["all"] = {
+        name: "all",
+        bpLength: l
+      };
+
+      function isDigit(val) {
+        return /^\d+$/.test(val);
+      }
+    }
+
+    /*
+     * The MIT License (MIT)
+     *
+     * Copyright (c) 2014 Broad Institute
+     *
+     * Permission is hereby granted, free of charge, to any person obtaining a copy
+     * of this software and associated documentation files (the "Software"), to deal
+     * in the Software without restriction, including without limitation the rights
+     * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+     * copies of the Software, and to permit persons to whom the Software is
+     * furnished to do so, subject to the following conditions:
+     *
+     * The above copyright notice and this permission notice shall be included in
+     * all copies or substantial portions of the Software.
+     *
+     *
+     * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+     * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+     * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+     * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+     * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+     * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+     * THE SOFTWARE.
+     */
+
+    class ViewportBase {
+      constructor(trackView, $viewportContainer, referenceFrame, width) {
+        this.guid = guid();
+        this.trackView = trackView;
+        this.referenceFrame = referenceFrame;
+        this.browser = trackView.browser;
+        this.$viewport = $('<div class="igv-viewport">');
+        $viewportContainer.append(this.$viewport); // store the viewport GUID for later use
+
+        this.$viewport.data('viewportGUID', this.guid);
+        this.$content = $("<div>", {
+          class: 'igv-viewport-content'
+        });
+        this.$viewport.append(this.$content);
+        this.$content.height(this.$viewport.height());
+        this.contentDiv = this.$content.get(0);
+        this.$canvas = $('<canvas class ="igv-canvas">');
+        this.$content.append(this.$canvas);
+        this.canvas = this.$canvas.get(0);
+        this.ctx = this.canvas.getContext("2d");
+        this.setWidth(width);
+        this.initializationHelper();
+      }
+
+      initializationHelper() {}
+
+      showMessage(message) {
+        if (!this.messageDiv) {
+          this.messageDiv = document.createElement('div');
+          this.messageDiv.className = 'igv-viewport-message';
+          this.contentDiv.append(this.messageDiv);
+        }
+
+        this.messageDiv.textContent = message;
+        this.messageDiv.style.display = 'inline-block';
+      }
+
+      hideMessage(message) {
+        if (this.messageDiv) this.messageDiv.style.display = 'none';
+      }
+
+      setTrackLabel(label) {}
+
+      startSpinner() {}
+
+      stopSpinner() {}
+
+      checkZoomIn() {
+        return true;
+      }
+
+      shift() {}
+
+      setTop(contentTop) {
+        const viewportHeight = this.$viewport.height();
+        const viewTop = -contentTop;
+        const viewBottom = viewTop + viewportHeight;
+        this.$content.css('top', `${contentTop}px`);
+
+        if (undefined === this.canvasVerticalRange || this.canvasVerticalRange.bottom < viewBottom || this.canvasVerticalRange.top > viewTop) {
+          this.repaint();
+        }
+      }
+
+      async loadFeatures() {
+        return undefined;
+      }
+
+      async repaint() {}
+
+      draw(drawConfiguration, features, roiFeatures) {}
+
+      checkContentHeight() {
+        let track = this.trackView.track;
+
+        if ("FILL" === track.displayMode) {
+          this.setContentHeight(this.$viewport.height());
+        } else if (typeof track.computePixelHeight === 'function') {
+          let features = this.cachedFeatures;
+
+          if (features && features.length > 0) {
+            let requiredContentHeight = track.computePixelHeight(features);
+            let currentContentHeight = this.$content.height();
+
+            if (requiredContentHeight !== currentContentHeight) {
+              this.setContentHeight(requiredContentHeight);
+            }
+          }
+        }
+      }
+
+      getContentHeight() {
+        return this.$content.height();
+      }
+
+      setContentHeight(contentHeight) {
+        // Maximum height of a canvas is ~32,000 pixels on Chrome, possibly smaller on other platforms
+        contentHeight = Math.min(contentHeight, 32000);
+        this.$content.height(contentHeight);
+        if (this.tile) this.tile.invalidate = true;
+      }
+
+      isLoading() {
+        return false;
+      }
+
+      saveSVG() {}
+
+      renderSVGContext(context, offset) {}
+
+      drawSVGWithContext(context) {}
+
+      isVisible() {
+        return this.$viewport.width();
+      }
+
+      setWidth(width) {
+        this.$viewport.width(width);
+        this.canvas.style.width = `${width}px`;
+        this.canvas.setAttribute('width', width);
+      }
+
+      getWidth() {
+        return this.$viewport.width();
+      }
+
+      getContentTop() {
+        return this.contentDiv.offsetTop;
+      }
+
+      containsPosition(chr, position) {}
+      /**
+       * Called when the associated track is removed.  Do any needed cleanup here.
+       */
+
+
+      dispose() {
+        if (this.popover) {
+          this.popover.dispose();
+        }
+
+        this.$canvas.off();
+        this.$canvas.empty();
+        this.$content.off();
+        this.$content.empty();
+        this.$viewport.off();
+        this.$viewport.empty(); // Null out all properties -- this should not be neccessary, but just in case there is a
+        // reference to self somewhere we want to free memory.
+
+        for (let key of Object.keys(this)) {
+          this[key] = undefined;
+        }
+      }
+
+    }
+
+    /*
+     * The MIT License (MIT)
+     *
+     * Copyright (c) 2014 Broad Institute
+     *
+     * Permission is hereby granted, free of charge, to any person obtaining a copy
+     * of this software and associated documentation files (the "Software"), to deal
+     * in the Software without restriction, including without limitation the rights
+     * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+     * copies of the Software, and to permit persons to whom the Software is
+     * furnished to do so, subject to the following conditions:
+     *
+     * The above copyright notice and this permission notice shall be included in
+     * all copies or substantial portions of the Software.
+     *
+     *
+     * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+     * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+     * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+     * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+     * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+     * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+     * THE SOFTWARE.
+     */
+    const trackMenuItemListHelper = MenuUtils.trackMenuItemListHelper;
+
+    const MenuPopup = function ($parent) {
+      // popover container
+      this.$popover = $('<div>', {
+        class: 'igv-menu-popup'
+      });
+      $parent.append(this.$popover); // popover header
+
+      let $popoverHeader = $('<div>', {
+        class: 'igv-menu-popup-header'
+      });
+      this.$popover.append($popoverHeader);
+      attachDialogCloseHandlerWithParent$1($popoverHeader.get(0), () => this.$popover.hide());
+      this.$popoverContent = $('<div>');
+      this.$popover.append(this.$popoverContent);
+      makeDraggable$1(this.$popover.get(0), $popoverHeader.get(0));
+      $popoverHeader.on('click.menu-popup-dismiss', function (e) {
+        e.stopPropagation();
+        e.preventDefault(); // absorb click to prevent it leaking through to parent DOM element
+      });
+    };
+
+    MenuPopup.prototype.presentMenuList = function (dx, dy, list) {
+      hideAllMenuPopups();
+
+      if (list.length > 0) {
+        this.$popoverContent.empty();
+        list = trackMenuItemListHelper(list, this.$popover);
+
+        for (let item of list) {
+          if (item.init) {
+            item.init();
+          }
+
+          let $e = item.object;
+
+          if (0 === list.indexOf(item)) {
+            $e.removeClass('igv-track-menu-border-top');
+          }
+
+          if ($e.hasClass('igv-track-menu-border-top') || $e.hasClass('igv-menu-popup-check-container')) ; else if ($e.is('div')) {
+            $e.addClass('igv-menu-popup-shim');
+          }
+
+          this.$popoverContent.append($e);
+        }
+
+        this.$popover.css({
+          left: dx + 'px',
+          top: dy + 'px'
+        });
+        this.$popover.show();
+      }
+    };
+
+    MenuPopup.prototype.presentTrackContextMenu = function (e, menuItems) {
+      this.$popoverContent.empty();
+      const menuElements = createMenuElements(menuItems, this.$popover.get(0));
+
+      for (let item of menuElements) {
+        this.$popoverContent.get(0).appendChild(item.object);
+      }
+
+      present(e, this.$popover.get(0));
+      this.$popover.show();
+    };
+
+    MenuPopup.prototype.dispose = function () {
+      this.$popover.empty();
+      this.$popoverContent.empty();
+      Object.keys(this).forEach(function (key) {
+        this[key] = undefined;
+      });
+    };
+
+    function createMenuElements(itemList, popover) {
+      return itemList.map(item => {
+        let elem;
+
+        if (typeof item === 'string' && '<hr/>' === item) {
+          elem = document.createElement('hr');
+        } else if (typeof item === 'string') {
+          elem = div$1({
+            class: 'context-menu'
+          });
+          elem.innerHTML = item;
+        } else if (typeof item === 'Node') {
+          elem = item;
+        } else {
+          if (typeof item.init === 'function') {
+            item.init();
+          }
+
+          if ("checkbox" === item.type) {
+            elem = Icon.createCheckbox("Show all bases", item.value);
+          } else if ("color" === item.type) {
+            const colorPicker = new ColorPicker({
+              parent: popover.parentElement,
+              width: 364,
+              //defaultColor: 'aqua',
+              colorHandler: color => item.click(color)
+            });
+            elem = div$1({
+              class: 'context-menu'
+            });
+
+            if (typeof item.label === 'string') {
+              elem.innerHTML = item.label;
+            }
+
+            const clickHandler = e => {
+              colorPicker.show();
+              hide$1(popover);
+              e.preventDefault();
+              e.stopPropagation();
+            };
+
+            elem.addEventListener('click', clickHandler);
+            elem.addEventListener('touchend', clickHandler);
+            elem.addEventListener('mouseup', function (e) {
+              e.preventDefault();
+              e.stopPropagation();
+            });
+          } else {
+            elem = div$1({
+              class: 'context-menu'
+            });
+
+            if (typeof item.label === 'string') {
+              elem.innerHTML = item.label;
+            }
+          }
+
+          if (item.click && "color" !== item.type) {
+            elem.addEventListener('click', handleClick);
+            elem.addEventListener('touchend', handleClick);
+            elem.addEventListener('mouseup', function (e) {
+              e.preventDefault();
+              e.stopPropagation();
+            }); // eslint-disable-next-line no-inner-declarations
+
+            function handleClick(e) {
+              item.click();
+              hide$1(popover);
+              e.preventDefault();
+              e.stopPropagation();
+            }
+          }
+        }
+
+        return {
+          object: elem,
+          init: item.init
+        };
+      });
+    }
+
+    function present(e, popover) {
+      const {
+        x,
+        y
+      } = translateMouseCoordinates$1(e, popover.parentNode); // parent bbox
+
+      const {
+        width
+      } = popover.parentNode.getBoundingClientRect();
+      const {
+        width: w
+      } = popover.getBoundingClientRect();
+      const xmax = x + w;
+      popover.style.left = `${xmax > width ? x - (xmax - width) : x}px`;
+      popover.style.top = `${y}px`;
+    }
+
+    const hideAllMenuPopups = () => $('.igv-menu-popup').hide();
+
+    /*!!
+     *  Canvas 2 Svg v1.0.19
+     *  A low level canvas to SVG converter. Uses a mock canvas context to build an SVG document.
+     *
+     *  Licensed under the MIT license:
+     *  http://www.opensource.org/licenses/mit-license.php
+     *
+     *  Author:
+     *  Kerry Liu
+     *
+     *  Copyright (c) 2014 Gliffy Inc.
+     */
+
+    var STYLES, ctx, CanvasGradient, CanvasPattern, namedEntities; //helper function to format a string
+
+    function format(str, args) {
+      var keys = Object.keys(args),
+          i;
+
+      for (i = 0; i < keys.length; i++) {
+        str = str.replace(new RegExp("\\{" + keys[i] + "\\}", "gi"), args[keys[i]]);
+      }
+
+      return str;
+    } //helper function that generates a random string
+
+
+    function randomString(holder) {
+      var chars, randomstring, i;
+
+      if (!holder) {
+        throw new Error("cannot create a random attribute name for an undefined object");
+      }
+
+      chars = "ABCDEFGHIJKLMNOPQRSTUVWXTZabcdefghiklmnopqrstuvwxyz";
+      randomstring = "";
+
+      do {
+        randomstring = "";
+
+        for (i = 0; i < 12; i++) {
+          randomstring += chars[Math.floor(Math.random() * chars.length)];
+        }
+      } while (holder[randomstring]);
+
+      return randomstring;
+    } //helper function to map named to numbered entities
+
+
+    function createNamedToNumberedLookup(items, radix) {
+      var i,
+          entity,
+          lookup = {},
+          base10;
+      items = items.split(',');
+      radix = radix || 10; // Map from named to numbered entities.
+
+      for (i = 0; i < items.length; i += 2) {
+        entity = '&' + items[i + 1] + ';';
+        base10 = parseInt(items[i], radix);
+        lookup[entity] = '&#' + base10 + ';';
+      } //FF and IE need to create a regex from hex values ie &nbsp; == \xa0
+
+
+      lookup["\\xa0"] = '&#160;';
+      return lookup;
+    } //helper function to map canvas-textAlign to svg-textAnchor
+
+
+    function getTextAnchor(textAlign) {
+      //TODO: support rtl languages
+      var mapping = {
+        "left": "start",
+        "right": "end",
+        "center": "middle",
+        "start": "start",
+        "end": "end"
+      };
+      return mapping[textAlign] || mapping.start;
+    } //helper function to map canvas-textBaseline to svg-dominantBaseline
+
+
+    function getDominantBaseline(textBaseline) {
+      //INFO: not supported in all browsers
+      var mapping = {
+        "alphabetic": "alphabetic",
+        "hanging": "hanging",
+        "top": "text-before-edge",
+        "bottom": "text-after-edge",
+        "middle": "central"
+      };
+      return mapping[textBaseline] || mapping.alphabetic;
+    } // Unpack entities lookup where the numbers are in radix 32 to reduce the size
+    // entity mapping courtesy of tinymce
+
+
+    namedEntities = createNamedToNumberedLookup('50,nbsp,51,iexcl,52,cent,53,pound,54,curren,55,yen,56,brvbar,57,sect,58,uml,59,copy,' + '5a,ordf,5b,laquo,5c,not,5d,shy,5e,reg,5f,macr,5g,deg,5h,plusmn,5i,sup2,5j,sup3,5k,acute,' + '5l,micro,5m,para,5n,middot,5o,cedil,5p,sup1,5q,ordm,5r,raquo,5s,frac14,5t,frac12,5u,frac34,' + '5v,iquest,60,Agrave,61,Aacute,62,Acirc,63,Atilde,64,Auml,65,Aring,66,AElig,67,Ccedil,' + '68,Egrave,69,Eacute,6a,Ecirc,6b,Euml,6c,Igrave,6d,Iacute,6e,Icirc,6f,Iuml,6g,ETH,6h,Ntilde,' + '6i,Ograve,6j,Oacute,6k,Ocirc,6l,Otilde,6m,Ouml,6n,times,6o,Oslash,6p,Ugrave,6q,Uacute,' + '6r,Ucirc,6s,Uuml,6t,Yacute,6u,THORN,6v,szlig,70,agrave,71,aacute,72,acirc,73,atilde,74,auml,' + '75,aring,76,aelig,77,ccedil,78,egrave,79,eacute,7a,ecirc,7b,euml,7c,igrave,7d,iacute,7e,icirc,' + '7f,iuml,7g,eth,7h,ntilde,7i,ograve,7j,oacute,7k,ocirc,7l,otilde,7m,ouml,7n,divide,7o,oslash,' + '7p,ugrave,7q,uacute,7r,ucirc,7s,uuml,7t,yacute,7u,thorn,7v,yuml,ci,fnof,sh,Alpha,si,Beta,' + 'sj,Gamma,sk,Delta,sl,Epsilon,sm,Zeta,sn,Eta,so,Theta,sp,Iota,sq,Kappa,sr,Lambda,ss,Mu,' + 'st,Nu,su,Xi,sv,Omicron,t0,Pi,t1,Rho,t3,Sigma,t4,Tau,t5,Upsilon,t6,Phi,t7,Chi,t8,Psi,' + 't9,Omega,th,alpha,ti,beta,tj,gamma,tk,delta,tl,epsilon,tm,zeta,tn,eta,to,theta,tp,iota,' + 'tq,kappa,tr,lambda,ts,mu,tt,nu,tu,xi,tv,omicron,u0,pi,u1,rho,u2,sigmaf,u3,sigma,u4,tau,' + 'u5,upsilon,u6,phi,u7,chi,u8,psi,u9,omega,uh,thetasym,ui,upsih,um,piv,812,bull,816,hellip,' + '81i,prime,81j,Prime,81u,oline,824,frasl,88o,weierp,88h,image,88s,real,892,trade,89l,alefsym,' + '8cg,larr,8ch,uarr,8ci,rarr,8cj,darr,8ck,harr,8dl,crarr,8eg,lArr,8eh,uArr,8ei,rArr,8ej,dArr,' + '8ek,hArr,8g0,forall,8g2,part,8g3,exist,8g5,empty,8g7,nabla,8g8,isin,8g9,notin,8gb,ni,8gf,prod,' + '8gh,sum,8gi,minus,8gn,lowast,8gq,radic,8gt,prop,8gu,infin,8h0,ang,8h7,and,8h8,or,8h9,cap,8ha,cup,' + '8hb,int,8hk,there4,8hs,sim,8i5,cong,8i8,asymp,8j0,ne,8j1,equiv,8j4,le,8j5,ge,8k2,sub,8k3,sup,8k4,' + 'nsub,8k6,sube,8k7,supe,8kl,oplus,8kn,otimes,8l5,perp,8m5,sdot,8o8,lceil,8o9,rceil,8oa,lfloor,8ob,' + 'rfloor,8p9,lang,8pa,rang,9ea,loz,9j0,spades,9j3,clubs,9j5,hearts,9j6,diams,ai,OElig,aj,oelig,b0,' + 'Scaron,b1,scaron,bo,Yuml,m6,circ,ms,tilde,802,ensp,803,emsp,809,thinsp,80c,zwnj,80d,zwj,80e,lrm,' + '80f,rlm,80j,ndash,80k,mdash,80o,lsquo,80p,rsquo,80q,sbquo,80s,ldquo,80t,rdquo,80u,bdquo,810,dagger,' + '811,Dagger,81g,permil,81p,lsaquo,81q,rsaquo,85c,euro', 32); //Some basic mappings for attributes and default values.
+
+    STYLES = {
+      "strokeStyle": {
+        svgAttr: "stroke",
+        //corresponding svg attribute
+        canvas: "#000000",
+        //canvas default
+        svg: "none",
+        //svg default
+        apply: "stroke" //apply on stroke() or fill()
+
+      },
+      "fillStyle": {
+        svgAttr: "fill",
+        canvas: "#000000",
+        svg: null,
+        //svg default is black, but we need to special case this to handle canvas stroke without fill
+        apply: "fill"
+      },
+      "lineCap": {
+        svgAttr: "stroke-linecap",
+        canvas: "butt",
+        svg: "butt",
+        apply: "stroke"
+      },
+      "lineJoin": {
+        svgAttr: "stroke-linejoin",
+        canvas: "miter",
+        svg: "miter",
+        apply: "stroke"
+      },
+      "miterLimit": {
+        svgAttr: "stroke-miterlimit",
+        canvas: 10,
+        svg: 4,
+        apply: "stroke"
+      },
+      "lineWidth": {
+        svgAttr: "stroke-width",
+        canvas: 1,
+        svg: 1,
+        apply: "stroke"
+      },
+      "globalAlpha": {
+        svgAttr: "opacity",
+        canvas: 1,
+        svg: 1,
+        apply: "fill stroke"
+      },
+      "font": {
+        //font converts to multiple svg attributes, there is custom logic for this
+        canvas: "10px sans-serif"
+      },
+      "shadowColor": {
+        canvas: "#000000"
+      },
+      "shadowOffsetX": {
+        canvas: 0
+      },
+      "shadowOffsetY": {
+        canvas: 0
+      },
+      "shadowBlur": {
+        canvas: 0
+      },
+      "textAlign": {
+        canvas: "start"
+      },
+      "textBaseline": {
+        canvas: "alphabetic"
+      },
+      "lineDash": {
+        svgAttr: "stroke-dasharray",
+        canvas: [],
+        svg: null,
+        apply: "stroke"
+      }
+    };
+    /**
+     *
+     * @param gradientNode - reference to the gradient
+     * @constructor
+     */
+
+    CanvasGradient = function (gradientNode, ctx) {
+      this.__root = gradientNode;
+      this.__ctx = ctx;
+    };
+    /**
+     * Adds a color stop to the gradient root
+     */
+
+
+    CanvasGradient.prototype.addColorStop = function (offset, color) {
+      var stop = this.__ctx.__createElement("stop"),
+          regex,
+          matches;
+
+      stop.setAttribute("offset", offset);
+
+      if (color && color.indexOf("rgba") !== -1) {
+        //separate alpha value, since webkit can't handle it
+        regex = /rgba\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d?\.?\d*)\s*\)/gi;
+        matches = regex.exec(color);
+        stop.setAttribute("stop-color", format("rgb({r},{g},{b})", {
+          r: matches[1],
+          g: matches[2],
+          b: matches[3]
+        }));
+        stop.setAttribute("stop-opacity", matches[4]);
+      } else {
+        stop.setAttribute("stop-color", color);
+      }
+
+      this.__root.appendChild(stop);
+    };
+
+    CanvasPattern = function (pattern, ctx) {
+      this.__root = pattern;
+      this.__ctx = ctx;
+    };
+    /**
+     * The mock canvas context
+     * @param config - options include:
+     * ctx - existing Context2D to wrap around
+     * width - width of your canvas (defaults to 500)
+     * height - height of your canvas (defaults to 500)
+     * enableMirroring - enables canvas mirroring (get image data) (defaults to false)
+     * document - the document object (defaults to the current document)
+     */
+
+
+    ctx = function (config) {
+      if (!(this instanceof ctx)) {
+        //did someone call this without new?
+        return new ctx(config);
+      } // clone config
+
+
+      this.config = config; //setup options
+
+      this.width = config.width;
+      this.height = config.height;
+      this.enableMirroring = config.enableMirroring || false;
+      this.canvas = this; ///point back to this instance!
+
+      this.__document = document; // allow passing in an existing context to wrap around
+      // if a context is passed in, we know a canvas already exist
+
+      if (config.ctx) {
+        this.__ctx = config.ctx;
+      } else {
+        this.__canvas = this.__document.createElement("canvas");
+        this.__ctx = this.__canvas.getContext("2d");
+      } // give this canvas a type
+
+
+      this.isSVG = true;
+
+      this.__setDefaultStyles();
+
+      this.__stack = [this.__getStyleState()];
+      this.__groupStack = []; // root svg element
+
+      this.__root = this.__createElement("svg");
+
+      this.__root.setAttribute("width", this.width);
+
+      this.__root.setAttribute("height", this.height); // allow contents to overflow svg bbox
+
+
+      this.__root.setAttribute('overflow', 'visible'); // viewbox
+
+
+      if (config.viewbox) {
+        const str = config.viewbox.x + ' ' + config.viewbox.y + ' ' + config.viewbox.width + ' ' + config.viewbox.height;
+
+        this.__root.setAttribute("viewBox", str);
+
+        this.viewbox = config.viewbox;
+      } // make sure we don't generate the same ids in defs
+
+
+      this.__ids = {}; // defs
+
+      this.__defs = this.__createElement("defs");
+
+      this.__root.appendChild(this.__defs);
+
+      this.multiLocusGap = config.multiLocusGap; // svg background color
+
+      let backdropConfig = {
+        id: 'svg_output_backdrop',
+        width: '100%',
+        height: '100%',
+        fill: config.backdropColor || 'white'
+      };
+
+      let backdropRect = this.__createElement('rect', backdropConfig);
+
+      this.__root.appendChild(backdropRect); // root group
+
+
+      this.__rootGroup = this.__createElement('g', {
+        id: 'root-group'
+      });
+
+      this.__root.appendChild(this.__rootGroup); // point current element to root group
+
+
+      this.__currentElement = this.__rootGroup;
+    };
+
+    ctx.prototype.setWidth = function (width) {
+      this.width = width;
+
+      this.__root.setAttribute("width", this.width);
+
+      const str = this.config.viewbox.x + ' ' + this.config.viewbox.y + ' ' + width + ' ' + this.config.viewbox.height;
+
+      this.__root.setAttribute("viewBox", str);
+    };
+
+    ctx.prototype.setHeight = function (height) {
+      this.height = height;
+
+      this.__root.setAttribute("height", this.height);
+
+      const str = this.config.viewbox.x + ' ' + this.config.viewbox.y + ' ' + this.config.viewbox.width + ' ' + height;
+
+      this.__root.setAttribute("viewBox", str);
+    };
+    /**
+     * Creates the specified svg element
+     * @private
+     */
+
+
+    ctx.prototype.__createElement = function (elementName, properties, resetFill) {
+      if (typeof properties === "undefined") {
+        properties = {};
+      }
+
+      let element = this.__document.createElementNS("http://www.w3.org/2000/svg", elementName);
+
+      if (resetFill) {
+        //if fill or stroke is not specified, the svg element should not display. By default SVG's fill is black.
+        element.setAttribute("fill", "none");
+        element.setAttribute("stroke", "none");
+      }
+
+      for (let key of Object.keys(properties)) {
+        element.setAttribute(key, properties[key]);
+      }
+
+      return element;
+    };
+    /**
+     * Applies default canvas styles to the context
+     * @private
+     */
+
+
+    ctx.prototype.__setDefaultStyles = function () {
+      //default 2d canvas context properties see:http://www.w3.org/TR/2dcontext/
+      var keys = Object.keys(STYLES),
+          i,
+          key;
+
+      for (i = 0; i < keys.length; i++) {
+        key = keys[i];
+        this[key] = STYLES[key].canvas;
+      }
+    };
+    /**
+     * Applies styles on restore
+     * @param styleState
+     * @private
+     */
+
+
+    ctx.prototype.__applyStyleState = function (styleState) {
+      var keys = Object.keys(styleState),
+          i,
+          key;
+
+      for (i = 0; i < keys.length; i++) {
+        key = keys[i];
+        this[key] = styleState[key];
+      }
+    };
+    /**
+     * Gets the current style state
+     * @return {Object}
+     * @private
+     */
+
+
+    ctx.prototype.__getStyleState = function () {
+      var i,
+          styleState = {},
+          keys = Object.keys(STYLES),
+          key;
+
+      for (i = 0; i < keys.length; i++) {
+        key = keys[i];
+        styleState[key] = this[key];
+      }
+
+      return styleState;
+    };
+    /**
+     * Apples the current styles to the current SVG element. On "ctx.fill" or "ctx.stroke"
+     * @param type
+     * @private
+     */
+
+
+    ctx.prototype.__applyStyleToCurrentElement = function (type) {
+      var currentElement = this.__currentElement;
+      var currentStyleGroup = this.__currentElementsToStyle;
+
+      if (currentStyleGroup) {
+        currentElement.setAttribute(type, "");
+        currentElement = currentStyleGroup.element;
+        currentStyleGroup.children.forEach(function (node) {
+          node.setAttribute(type, "");
+        });
+      }
+
+      var keys = Object.keys(STYLES),
+          i,
+          style,
+          value,
+          id,
+          regex,
+          matches;
+
+      for (i = 0; i < keys.length; i++) {
+        style = STYLES[keys[i]];
+        value = this[keys[i]];
+
+        if (style.apply) {
+          //is this a gradient or pattern?
+          if (value instanceof CanvasPattern) {
+            //pattern
+            if (value.__ctx) {
+              //copy over defs
+              while (value.__ctx.__defs.childNodes.length) {
+                id = value.__ctx.__defs.childNodes[0].getAttribute("id");
+                this.__ids[id] = id;
+
+                this.__defs.appendChild(value.__ctx.__defs.childNodes[0]);
+              }
+            }
+
+            currentElement.setAttribute(style.apply, format("url(#{id})", {
+              id: value.__root.getAttribute("id")
+            }));
+          } else if (value instanceof CanvasGradient) {
+            //gradient
+            currentElement.setAttribute(style.apply, format("url(#{id})", {
+              id: value.__root.getAttribute("id")
+            }));
+          } else if (style && style.apply.indexOf(type) !== -1 && style.svg !== value) {
+            if ((style.svgAttr === "stroke" || style.svgAttr === "fill") && value && value.indexOf("rgba") !== -1) {
+              //separate alpha value, since illustrator can't handle it
+              regex = /rgba\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d?\.?\d*)\s*\)/gi;
+              matches = regex.exec(value);
+              currentElement.setAttribute(style.svgAttr, format("rgb({r},{g},{b})", {
+                r: matches[1],
+                g: matches[2],
+                b: matches[3]
+              })); //should take globalAlpha here
+
+              var opacity = matches[4];
+              var globalAlpha = this.globalAlpha;
+
+              if (globalAlpha != null) {
+                opacity *= globalAlpha;
+              }
+
+              currentElement.setAttribute(style.svgAttr + "-opacity", opacity);
+            } else {
+              var attr = style.svgAttr;
+
+              if (keys[i] === 'globalAlpha') {
+                attr = type + '-' + style.svgAttr;
+
+                if (currentElement.getAttribute(attr)) {
+                  //fill-opacity or stroke-opacity has already been set by stroke or fill.
+                  continue;
+                }
+              } //otherwise only update attribute if right type, and not svg default
+
+
+              currentElement.setAttribute(attr, value);
+            }
+          }
+        }
+      }
+    };
+    /**
+     * Will return the closest group or svg node. May return the current element.
+     * @private
+     */
+
+
+    ctx.prototype.__closestGroupOrSvg = function (node) {
+      node = node || this.__currentElement;
+
+      if (node.nodeName === "g" || node.nodeName === "svg") {
+        return node;
+      } else {
+        return this.__closestGroupOrSvg(node.parentNode);
+      }
+    };
+    /**
+     * Returns the serialized value of the svg so far
+     * @param fixNamedEntities - Standalone SVG doesn't support named entities, which document.createTextNode encodes.
+     *                           If true, we attempt to find all named entities and encode it as a numeric entity.
+     * @return serialized svg
+     */
+
+
+    ctx.prototype.getSerializedSvg = function (fixNamedEntities) {
+      var serialized = new XMLSerializer().serializeToString(this.__root),
+          keys,
+          i,
+          key,
+          value,
+          regexp;
+     //IE search for a duplicate xmnls because they didn't implement setAttributeNS correctly
+      // xmlns = /xmlns="http:\/\/www\.w3\.org\/2000\/svg".+xmlns="http:\/\/www\.w3\.org\/2000\/svg/gi;
+      // if (xmlns.test(serialized)) {
+      //     serialized = serialized.replace('xmlns="http://www.w3.org/2000/svg','xmlns:xlink="http://www.w3.org/1999/xlink');
+      // }
+
+      if (fixNamedEntities) {
+        keys = Object.keys(namedEntities); //loop over each named entity and replace with the proper equivalent.
+
+        for (i = 0; i < keys.length; i++) {
+          key = keys[i];
+          value = namedEntities[key];
+          regexp = new RegExp(key, "gi");
+
+          if (regexp.test(serialized)) {
+            serialized = serialized.replace(regexp, value);
+          }
+        }
+      }
+
+      return serialized;
+    };
+    /**
+     * Returns the root svg
+     * @return
+     */
+
+
+    ctx.prototype.getSvg = function () {
+      return this.__root;
+    };
+    /**
+     * Will generate a group tag.
+     */
+
+
+    ctx.prototype.saveWithTranslationAndClipRect = function (id, tx, ty, width, height, clipYOffset) {
+      // clip rect
+      const clip_id = `${id}_clip_rect`;
+
+      let clipPath = this.__createElement('clipPath', {
+        id: clip_id
+      });
+
+      this.__defs.appendChild(clipPath);
+
+      const config = {
+        x: '0',
+        y: clipYOffset.toString(),
+        width: width.toString(),
+        height: height.toString()
+      };
+      clipPath.appendChild(this.__createElement('rect', config));
+
+      const group = this.__createElement("g");
+
+      group.setAttribute('transform', format('translate({x},{y})', {
+        x: tx,
+        y: ty
+      }));
+      group.setAttribute('clip-path', format('url(#{id})', {
+        id: clip_id
+      }));
+
+      const parent = this.__closestGroupOrSvg();
+
+      parent.appendChild(group);
+
+      this.__groupStack.push(parent);
+
+      this.__currentElement = group;
+
+      this.__stack.push(this.__getStyleState());
+    };
+
+    ctx.prototype.save = function () {
+      var group = this.__createElement("g");
+
+      var parent = this.__closestGroupOrSvg();
+
+      this.__groupStack.push(parent);
+
+      parent.appendChild(group);
+      this.__currentElement = group;
+
+      this.__stack.push(this.__getStyleState());
+    };
+    /**
+     * Sets current element to parent, or just root if already root
+     */
+
+
+    ctx.prototype.restore = function () {
+      this.__currentElement = this.__groupStack.pop();
+      this.__currentElementsToStyle = null; //Clearing canvas will make the poped group invalid, currentElement is set to the root group node.
+
+      if (!this.__currentElement) {
+        this.__currentElement = this.__root.childNodes[1];
+      }
+
+      var state = this.__stack.pop();
+
+      this.__applyStyleState(state);
+    };
+    /**
+     * Helper method to add transform
+     * @private
+     */
+
+
+    ctx.prototype.__addTransform = function (t) {
+      //if the current element has siblings, add another group
+      var parent = this.__closestGroupOrSvg();
+
+      if (parent.childNodes.length > 0) {
+        if (this.__currentElement.nodeName === "path") {
+          if (!this.__currentElementsToStyle) this.__currentElementsToStyle = {
+            element: parent,
+            children: []
+          };
+
+          this.__currentElementsToStyle.children.push(this.__currentElement);
+
+          this.__applyCurrentDefaultPath();
+        }
+
+        var group = this.__createElement("g");
+
+        parent.appendChild(group);
+        this.__currentElement = group;
+      }
+
+      var transform = this.__currentElement.getAttribute("transform");
+
+      if (transform) {
+        transform += " ";
+      } else {
+        transform = "";
+      }
+
+      transform += t;
+
+      this.__currentElement.setAttribute("transform", transform);
+    };
+
+    ctx.prototype.addTrackGroupWithTranslationAndClipRect = function (id, tx, ty, width, height, clipYOffset) {
+      // clip rect
+      const clip_id = id + '_clip_rect';
+
+      let clipPath = this.__createElement('clipPath', {
+        id: clip_id
+      });
+
+      this.__defs.appendChild(clipPath);
+
+      clipPath.appendChild(this.__createElement('rect', {
+        x: '0',
+        y: clipYOffset.toString(),
+        width: width.toString(),
+        height: height.toString()
+      }));
+
+      let group = this.__createElement('g');
+
+      this.__rootGroup.appendChild(group);
+
+      group.setAttribute('transform', format('translate({x},{y})', {
+        x: tx,
+        y: ty
+      }));
+      group.setAttribute('id', id + '_group'); // add clip rect
+
+      group.setAttribute('clip-path', format('url(#{id})', {
+        id: clip_id
+      }));
+      this.__currentElement = group;
+    };
+    /**
+     *  scales the current element
+     */
+
+
+    ctx.prototype.scale = function (x, y) {
+      if (y === undefined) {
+        y = x;
+      }
+
+      this.__addTransform(format("scale({x},{y})", {
+        x: x,
+        y: y
+      }));
+    };
+    /**
+     * rotates the current element
+     */
+
+
+    ctx.prototype.rotate = function (angle) {
+      var degrees = angle * 180 / Math.PI;
+
+      this.__addTransform(format("rotate({angle},{cx},{cy})", {
+        angle: degrees,
+        cx: 0,
+        cy: 0
+      }));
+    };
+    /**
+     * translates the current element
+     */
+
+
+    ctx.prototype.translate = function (x, y) {
+      this.__addTransform(format("translate({x},{y})", {
+        x: x,
+        y: y
+      }));
+    };
+    /**
+     * applies a transform to the current element
+     */
+
+
+    ctx.prototype.transform = function (a, b, c, d, e, f) {
+      this.__addTransform(format("matrix({a},{b},{c},{d},{e},{f})", {
+        a: a,
+        b: b,
+        c: c,
+        d: d,
+        e: e,
+        f: f
+      }));
+    };
+    /**
+     * Create a new Path Element
+     */
+
+
+    ctx.prototype.beginPath = function () {
+      var path, parent; // Note that there is only one current default path, it is not part of the drawing state.
+      // See also: https://html.spec.whatwg.org/multipage/scripting.html#current-default-path
+
+      this.__currentDefaultPath = "";
+      this.__currentPosition = {};
+      path = this.__createElement("path", {}, true);
+      parent = this.__closestGroupOrSvg();
+      parent.appendChild(path);
+      this.__currentElement = path;
+    };
+    /**
+     * Helper function to apply currentDefaultPath to current path element
+     * @private
+     */
+
+
+    ctx.prototype.__applyCurrentDefaultPath = function () {
+      var currentElement = this.__currentElement;
+
+      if (currentElement.nodeName === "path") {
+        currentElement.setAttribute("d", this.__currentDefaultPath);
+      } else {
+        console.error("Attempted to apply path command to node", currentElement.nodeName);
+      }
+    };
+    /**
+     * Helper function to add path command
+     * @private
+     */
+
+
+    ctx.prototype.__addPathCommand = function (command) {
+      this.__currentDefaultPath += " ";
+      this.__currentDefaultPath += command;
+    };
+    /**
+     * Adds the move command to the current path element,
+     * if the currentPathElement is not empty create a new path element
+     */
+
+
+    ctx.prototype.moveTo = function (x, y) {
+      if (this.__currentElement.nodeName !== "path") {
+        this.beginPath();
+      } // creates a new subpath with the given point
+
+
+      this.__currentPosition = {
+        x: x,
+        y: y
+      };
+
+      this.__addPathCommand(format("M {x} {y}", {
+        x: x,
+        y: y
+      }));
+    };
+    /**
+     * Closes the current path
+     */
+
+
+    ctx.prototype.closePath = function () {
+      if (this.__currentDefaultPath) {
+        this.__addPathCommand("Z");
+      }
+    };
+    /**
+     * Adds a line to command
+     */
+
+
+    ctx.prototype.lineTo = function (x, y) {
+      this.__currentPosition = {
+        x: x,
+        y: y
+      };
+
+      if (this.__currentDefaultPath && this.__currentDefaultPath.indexOf('M') > -1) {
+        this.__addPathCommand(format("L {x} {y}", {
+          x: x,
+          y: y
+        }));
+      } else {
+        this.__addPathCommand(format("M {x} {y}", {
+          x: x,
+          y: y
+        }));
+      }
+    };
+    /**
+     * Add a bezier command
+     */
+
+
+    ctx.prototype.bezierCurveTo = function (cp1x, cp1y, cp2x, cp2y, x, y) {
+      this.__currentPosition = {
+        x: x,
+        y: y
+      };
+
+      this.__addPathCommand(format("C {cp1x} {cp1y} {cp2x} {cp2y} {x} {y}", {
+        cp1x: cp1x,
+        cp1y: cp1y,
+        cp2x: cp2x,
+        cp2y: cp2y,
+        x: x,
+        y: y
+      }));
+    };
+    /**
+     * Adds a quadratic curve to command
+     */
+
+
+    ctx.prototype.quadraticCurveTo = function (cpx, cpy, x, y) {
+      this.__currentPosition = {
+        x: x,
+        y: y
+      };
+
+      this.__addPathCommand(format("Q {cpx} {cpy} {x} {y}", {
+        cpx: cpx,
+        cpy: cpy,
+        x: x,
+        y: y
+      }));
+    };
+    /**
+     * Return a new normalized vector of given vector
+     */
+
+
+    var normalize$1 = function (vector) {
+      var len = Math.sqrt(vector[0] * vector[0] + vector[1] * vector[1]);
+      return [vector[0] / len, vector[1] / len];
+    };
+    /**
+     * Adds the arcTo to the current path
+     *
+     * @see http://www.w3.org/TR/2015/WD-2dcontext-20150514/#dom-context-2d-arcto
+     */
+
+
+    ctx.prototype.arcTo = function (x1, y1, x2, y2, radius) {
+      // Let the point (x0, y0) be the last point in the subpath.
+      var x0 = this.__currentPosition && this.__currentPosition.x;
+      var y0 = this.__currentPosition && this.__currentPosition.y; // First ensure there is a subpath for (x1, y1).
+
+      if (typeof x0 == "undefined" || typeof y0 == "undefined") {
+        return;
+      } // Negative values for radius must cause the implementation to throw an IndexSizeError exception.
+
+
+      if (radius < 0) {
+        throw new Error("IndexSizeError: The radius provided (" + radius + ") is negative.");
+      } // If the point (x0, y0) is equal to the point (x1, y1),
+      // or if the point (x1, y1) is equal to the point (x2, y2),
+      // or if the radius radius is zero,
+      // then the method must add the point (x1, y1) to the subpath,
+      // and connect that point to the previous point (x0, y0) by a straight line.
+
+
+      if (x0 === x1 && y0 === y1 || x1 === x2 && y1 === y2 || radius === 0) {
+        this.lineTo(x1, y1);
+        return;
+      } // Otherwise, if the points (x0, y0), (x1, y1), and (x2, y2) all lie on a single straight line,
+      // then the method must add the point (x1, y1) to the subpath,
+      // and connect that point to the previous point (x0, y0) by a straight line.
+
+
+      var unit_vec_p1_p0 = normalize$1([x0 - x1, y0 - y1]);
+      var unit_vec_p1_p2 = normalize$1([x2 - x1, y2 - y1]);
+
+      if (unit_vec_p1_p0[0] * unit_vec_p1_p2[1] === unit_vec_p1_p0[1] * unit_vec_p1_p2[0]) {
+        this.lineTo(x1, y1);
+        return;
+      } // Otherwise, let The Arc be the shortest arc given by circumference of the circle that has radius radius,
+      // and that has one point tangent to the half-infinite line that crosses the point (x0, y0) and ends at the point (x1, y1),
+      // and that has a different point tangent to the half-infinite line that ends at the point (x1, y1), and crosses the point (x2, y2).
+      // The points at which this circle touches these two lines are called the start and end tangent points respectively.
+      // note that both vectors are unit vectors, so the length is 1
+
+
+      var cos = unit_vec_p1_p0[0] * unit_vec_p1_p2[0] + unit_vec_p1_p0[1] * unit_vec_p1_p2[1];
+      var theta = Math.acos(Math.abs(cos)); // Calculate origin
+
+      var unit_vec_p1_origin = normalize$1([unit_vec_p1_p0[0] + unit_vec_p1_p2[0], unit_vec_p1_p0[1] + unit_vec_p1_p2[1]]);
+      var len_p1_origin = radius / Math.sin(theta / 2);
+      var x = x1 + len_p1_origin * unit_vec_p1_origin[0];
+      var y = y1 + len_p1_origin * unit_vec_p1_origin[1]; // Calculate start angle and end angle
+      // rotate 90deg clockwise (note that y axis points to its down)
+
+      var unit_vec_origin_start_tangent = [-unit_vec_p1_p0[1], unit_vec_p1_p0[0]]; // rotate 90deg counter clockwise (note that y axis points to its down)
+
+      var unit_vec_origin_end_tangent = [unit_vec_p1_p2[1], -unit_vec_p1_p2[0]];
+
+      var getAngle = function (vector) {
+        // get angle (clockwise) between vector and (1, 0)
+        var x = vector[0];
+        var y = vector[1];
+
+        if (y >= 0) {
+          // note that y axis points to its down
+          return Math.acos(x);
+        } else {
+          return -Math.acos(x);
+        }
+      };
+
+      var startAngle = getAngle(unit_vec_origin_start_tangent);
+      var endAngle = getAngle(unit_vec_origin_end_tangent); // Connect the point (x0, y0) to the start tangent point by a straight line
+
+      this.lineTo(x + unit_vec_origin_start_tangent[0] * radius, y + unit_vec_origin_start_tangent[1] * radius); // Connect the start tangent point to the end tangent point by arc
+      // and adding the end tangent point to the subpath.
+
+      this.arc(x, y, radius, startAngle, endAngle);
+    };
+    /**
+     * Sets the stroke property on the current element
+     */
+
+
+    ctx.prototype.stroke = function () {
+      if (this.__currentElement.nodeName === "path") {
+        this.__currentElement.setAttribute("paint-order", "fill stroke markers");
+      }
+
+      this.__applyCurrentDefaultPath();
+
+      this.__applyStyleToCurrentElement("stroke");
+    };
+    /**
+     * Sets fill properties on the current element
+     */
+
+
+    ctx.prototype.fill = function () {
+      if (this.__currentElement.nodeName === "path") {
+        this.__currentElement.setAttribute("paint-order", "stroke fill markers");
+      }
+
+      this.__applyCurrentDefaultPath();
+
+      this.__applyStyleToCurrentElement("fill");
+    };
+    /**
+     *  Adds a rectangle to the path.
+     */
+
+
+    ctx.prototype.rect = function (x, y, width, height) {
+      if (this.__currentElement.nodeName !== "path") {
+        this.beginPath();
+      }
+
+      this.moveTo(x, y);
+      this.lineTo(x + width, y);
+      this.lineTo(x + width, y + height);
+      this.lineTo(x, y + height);
+      this.lineTo(x, y);
+      this.closePath();
+    };
+    /**
+     * adds a rectangle element
+     */
+
+
+    ctx.prototype.fillRect = function (x, y, width, height) {
+      if (height < 0) {
+        y += height;
+        height = -height;
+      }
+
+      if (width < 0) {
+        x += width;
+        width = -width;
+      } // See if rect instersects current viewbox
+
+
+      var r2 = {
+        x: x,
+        y: y,
+        width: width,
+        height: height
+      };
+
+      if (this.viewbox) {
+        if (!intersectRect(this.viewbox, r2)) {
+          return;
+        }
+      }
+
+      var rect, parent;
+      rect = this.__createElement("rect", r2, true);
+      parent = this.__closestGroupOrSvg();
+      parent.appendChild(rect);
+      this.__currentElement = rect;
+
+      this.__applyStyleToCurrentElement("fill");
+    };
+
+    function intersectRect(rect1, rect2) {
+      return rect1.x < rect2.x + rect2.width && rect1.x + rect1.width > rect2.x && rect1.y < rect2.y + rect2.height && rect1.y + rect1.height > rect2.y;
+    }
+    /**
+     * Draws a rectangle with no fill
+     * @param x
+     * @param y
+     * @param width
+     * @param height
+     */
+
+
+    ctx.prototype.strokeRect = function (x, y, width, height) {
+      var rect, parent;
+      rect = this.__createElement("rect", {
+        x: x,
+        y: y,
+        width: width,
+        height: height
+      }, true);
+      parent = this.__closestGroupOrSvg();
+      parent.appendChild(rect);
+      this.__currentElement = rect;
+
+      this.__applyStyleToCurrentElement("stroke");
+    };
+    /**
+     * Clear entire canvas:
+     * 1. save current transforms
+     * 2. remove all the childNodes of the root g element
+     */
+
+
+    ctx.prototype.__clearCanvas = function () {
+      var current = this.__closestGroupOrSvg(),
+          transform = current.getAttribute("transform");
+
+      var rootGroup = this.__root.childNodes[1];
+      var childNodes = rootGroup.childNodes;
+
+      for (var i = childNodes.length - 1; i >= 0; i--) {
+        if (childNodes[i]) {
+          rootGroup.removeChild(childNodes[i]);
+        }
+      }
+
+      this.__currentElement = rootGroup; //reset __groupStack as all the child group nodes are all removed.
+
+      this.__groupStack = [];
+
+      if (transform) {
+        this.__addTransform(transform);
+      }
+    };
+    /**
+     * "Clears" a canvas by just drawing a white rectangle in the current group.
+     */
+
+
+    ctx.prototype.clearRect = function (x, y, width, height) {
+      //clear entire canvas
+      if (x === 0 && y === 0 && width === this.width && height === this.height) {
+        this.__clearCanvas();
+
+        return;
+      }
+
+      var rect,
+          parent = this.__closestGroupOrSvg();
+
+      rect = this.__createElement("rect", {
+        x: x,
+        y: y,
+        width: width,
+        height: height,
+        fill: "#FFFFFF"
+      }, true);
+      parent.appendChild(rect);
+    };
+    /**
+     * Adds a linear gradient to a defs tag.
+     * Returns a canvas gradient object that has a reference to it's parent def
+     */
+
+
+    ctx.prototype.createLinearGradient = function (x1, y1, x2, y2) {
+      var grad = this.__createElement("linearGradient", {
+        id: randomString(this.__ids),
+        x1: x1 + "px",
+        x2: x2 + "px",
+        y1: y1 + "px",
+        y2: y2 + "px",
+        "gradientUnits": "userSpaceOnUse"
+      }, false);
+
+      this.__defs.appendChild(grad);
+
+      return new CanvasGradient(grad, this);
+    };
+    /**
+     * Adds a radial gradient to a defs tag.
+     * Returns a canvas gradient object that has a reference to it's parent def
+     */
+
+
+    ctx.prototype.createRadialGradient = function (x0, y0, r0, x1, y1, r1) {
+      var grad = this.__createElement("radialGradient", {
+        id: randomString(this.__ids),
+        cx: x1 + "px",
+        cy: y1 + "px",
+        r: r1 + "px",
+        fx: x0 + "px",
+        fy: y0 + "px",
+        "gradientUnits": "userSpaceOnUse"
+      }, false);
+
+      this.__defs.appendChild(grad);
+
+      return new CanvasGradient(grad, this);
+    };
+    /**
+     * Parses the font string and returns svg mapping
+     * @private
+     */
+
+
+    ctx.prototype.__parseFont = function () {
+      var regex = /^\s*(?=(?:(?:[-a-z]+\s*){0,2}(italic|oblique))?)(?=(?:(?:[-a-z]+\s*){0,2}(small-caps))?)(?=(?:(?:[-a-z]+\s*){0,2}(bold(?:er)?|lighter|[1-9]00))?)(?:(?:normal|\1|\2|\3)\s*){0,3}((?:xx?-)?(?:small|large)|medium|smaller|larger|[.\d]+(?:\%|in|[cem]m|ex|p[ctx]))(?:\s*\/\s*(normal|[.\d]+(?:\%|in|[cem]m|ex|p[ctx])))?\s*([-,\'\"\sa-z0-9]+?)\s*$/i;
+      var fontPart = regex.exec(this.font);
+      var data = {
+        style: fontPart[1] || 'normal',
+        size: fontPart[4] || '10px',
+        family: fontPart[6] || 'sans-serif',
+        weight: fontPart[3] || 'normal',
+        decoration: fontPart[2] || 'normal',
+        href: null
+      }; //canvas doesn't support underline natively, but we can pass this attribute
+
+      if (this.__fontUnderline === "underline") {
+        data.decoration = "underline";
+      } //canvas also doesn't support linking, but we can pass this as well
+
+
+      if (this.__fontHref) {
+        data.href = this.__fontHref;
+      }
+
+      return data;
+    };
+    /**
+     * Helper to link text fragments
+     * @param font
+     * @param element
+     * @return {*}
+     * @private
+     */
+
+
+    ctx.prototype.__wrapTextLink = function (font, element) {
+      if (font.href) {
+        var a = this.__createElement("a");
+
+        a.setAttributeNS("http://www.w3.org/1999/xlink", "xlink:href", font.href);
+        a.appendChild(element);
+        return a;
+      }
+
+      return element;
+    };
+    /**
+     * Fills or strokes text
+     * @param text
+     * @param x
+     * @param y
+     * @param action - stroke or fill
+     * @private
+     */
+
+
+    ctx.prototype.__applyText = function (text, x, y, action) {
+      var font = this.__parseFont(),
+          parent = this.__closestGroupOrSvg(),
+          textElement = this.__createElement("text", {
+        "font-family": font.family,
+        "font-size": font.size,
+        "font-style": font.style,
+        "font-weight": font.weight,
+        "text-decoration": font.decoration,
+        "x": x,
+        "y": y,
+        "text-anchor": getTextAnchor(this.textAlign),
+        "dominant-baseline": getDominantBaseline(this.textBaseline)
+      }, true);
+
+      textElement.appendChild(this.__document.createTextNode(text));
+      this.__currentElement = textElement;
+
+      this.__applyStyleToCurrentElement(action);
+
+      parent.appendChild(this.__wrapTextLink(font, textElement));
+    };
+    /**
+     * Creates a text element
+     * @param text
+     * @param x
+     * @param y
+     */
+
+
+    ctx.prototype.fillText = function (text, x, y) {
+      this.__applyText(text, x, y, "fill");
+    };
+    /**
+     * Strokes text
+     * @param text
+     * @param x
+     * @param y
+     */
+
+
+    ctx.prototype.strokeText = function (text, x, y) {
+      this.__applyText(text, x, y, "stroke");
+    };
+    /**
+     * No need to implement this for svg.
+     * @param text
+     * @return {TextMetrics}
+     */
+
+
+    ctx.prototype.measureText = function (text) {
+      this.__ctx.font = this.font;
+      return this.__ctx.measureText(text);
+    };
+    /**
+     *  Arc command!
+     */
+
+
+    ctx.prototype.arc = function (x, y, radius, startAngle, endAngle, counterClockwise) {
+      // in canvas no circle is drawn if no angle is provided.
+      if (startAngle === endAngle) {
+        return;
+      }
+
+      startAngle = startAngle % (2 * Math.PI);
+      endAngle = endAngle % (2 * Math.PI);
+
+      if (startAngle === endAngle) {
+        //circle time! subtract some of the angle so svg is happy (svg elliptical arc can't draw a full circle)
+        endAngle = (endAngle + 2 * Math.PI - 0.001 * (counterClockwise ? -1 : 1)) % (2 * Math.PI);
+      }
+
+      var endX = x + radius * Math.cos(endAngle),
+          endY = y + radius * Math.sin(endAngle),
+          startX = x + radius * Math.cos(startAngle),
+          startY = y + radius * Math.sin(startAngle),
+          sweepFlag = counterClockwise ? 0 : 1,
+          largeArcFlag = 0,
+          diff = endAngle - startAngle; // https://github.com/gliffy/canvas2svg/issues/4
+
+      if (diff < 0) {
+        diff += 2 * Math.PI;
+      }
+
+      if (counterClockwise) {
+        largeArcFlag = diff > Math.PI ? 0 : 1;
+      } else {
+        largeArcFlag = diff > Math.PI ? 1 : 0;
+      }
+
+      this.lineTo(startX, startY);
+
+      this.__addPathCommand(format("A {rx} {ry} {xAxisRotation} {largeArcFlag} {sweepFlag} {endX} {endY}", {
+        rx: radius,
+        ry: radius,
+        xAxisRotation: 0,
+        largeArcFlag: largeArcFlag,
+        sweepFlag: sweepFlag,
+        endX: endX,
+        endY: endY
+      }));
+
+      this.__currentPosition = {
+        x: endX,
+        y: endY
+      };
+    };
+    /**
+     * Generates a ClipPath from the clip command.
+     */
+
+
+    ctx.prototype.clip = function () {
+      var group = this.__closestGroupOrSvg(),
+          clipPath = this.__createElement("clipPath"),
+          id = randomString(this.__ids),
+          newGroup = this.__createElement("g");
+
+      this.__applyCurrentDefaultPath();
+
+      group.removeChild(this.__currentElement);
+      clipPath.setAttribute("id", id);
+      clipPath.appendChild(this.__currentElement);
+
+      this.__defs.appendChild(clipPath); //set the clip path to this group
+
+
+      group.setAttribute("clip-path", format("url(#{id})", {
+        id: id
+      })); //clip paths can be scaled and transformed, we need to add another wrapper group to avoid later transformations
+      // to this path
+
+      group.appendChild(newGroup);
+      this.__currentElement = newGroup;
+    };
+    /**
+     * Draws a canvas, image or mock context to this canvas.
+     * Note that all svg dom manipulation uses node.childNodes rather than node.children for IE support.
+     * http://www.whatwg.org/specs/web-apps/current-work/multipage/the-canvas-element.html#dom-context-2d-drawimage
+     */
+
+
+    ctx.prototype.drawImage = function () {
+      //convert arguments to a real array
+      var args = Array.prototype.slice.call(arguments),
+          image = args[0],
+          dx,
+          dy,
+          dw,
+          dh,
+          sx = 0,
+          sy = 0,
+          sw,
+          sh,
+          parent,
+          svg,
+          defs,
+          group,
+          svgImage,
+          canvas,
+          context,
+          id;
+
+      if (args.length === 3) {
+        dx = args[1];
+        dy = args[2];
+        sw = image.width;
+        sh = image.height;
+        dw = sw;
+        dh = sh;
+      } else if (args.length === 5) {
+        dx = args[1];
+        dy = args[2];
+        dw = args[3];
+        dh = args[4];
+        sw = image.width;
+        sh = image.height;
+      } else if (args.length === 9) {
+        sx = args[1];
+        sy = args[2];
+        sw = args[3];
+        sh = args[4];
+        dx = args[5];
+        dy = args[6];
+        dw = args[7];
+        dh = args[8];
+      } else {
+        throw new Error("Invalid number of arguments passed to drawImage: " + arguments.length);
+      }
+
+      parent = this.__closestGroupOrSvg();
+      var translateDirective = "translate(" + dx + ", " + dy + ")";
+
+      if (image instanceof ctx) {
+        //canvas2svg mock canvas context. In the future we may want to clone nodes instead.
+        //also I'm currently ignoring dw, dh, sw, sh, sx, sy for a mock context.
+        svg = image.getSvg().cloneNode(true);
+
+        if (svg.childNodes && svg.childNodes.length > 1) {
+          defs = svg.childNodes[0];
+
+          while (defs.childNodes.length) {
+            id = defs.childNodes[0].getAttribute("id");
+            this.__ids[id] = id;
+
+            this.__defs.appendChild(defs.childNodes[0]);
+          }
+
+          group = svg.childNodes[1];
+
+          if (group) {
+            //save original transform
+            var originTransform = group.getAttribute("transform");
+            var transformDirective;
+
+            if (originTransform) {
+              transformDirective = originTransform + " " + translateDirective;
+            } else {
+              transformDirective = translateDirective;
+            }
+
+            group.setAttribute("transform", transformDirective);
+            parent.appendChild(group);
+          }
+        }
+      } else if (image.nodeName === "CANVAS" || image.nodeName === "IMG") {
+        //canvas or image
+        svgImage = this.__createElement("image");
+        svgImage.setAttribute("width", dw);
+        svgImage.setAttribute("height", dh);
+        svgImage.setAttribute("preserveAspectRatio", "none");
+
+        if (sx || sy || sw !== image.width || sh !== image.height) {
+          //crop the image using a temporary canvas
+          canvas = this.__document.createElement("canvas");
+          canvas.width = dw;
+          canvas.height = dh;
+          context = canvas.getContext("2d");
+          context.drawImage(image, sx, sy, sw, sh, 0, 0, dw, dh);
+          image = canvas;
+        }
+
+        svgImage.setAttribute("transform", translateDirective);
+        svgImage.setAttributeNS("http://www.w3.org/1999/xlink", "xlink:href", image.nodeName === "CANVAS" ? image.toDataURL() : image.getAttribute("src"));
+        parent.appendChild(svgImage);
+      }
+    };
+    /**
+     * Generates a pattern tag
+     */
+
+
+    ctx.prototype.createPattern = function (image, repetition) {
+      let pattern = this.__document.__createElement("pattern");
+
+      let id = randomString(this.__ids);
+      let img;
+      pattern.setAttribute("id", id);
+      pattern.setAttribute("width", image.width);
+      pattern.setAttribute("height", image.height);
+
+      if (image.nodeName === "CANVAS" || image.nodeName === "IMG") {
+        img = this.__createElement("image");
+        img.setAttribute("width", image.width);
+        img.setAttribute("height", image.height);
+        img.setAttributeNS("http://www.w3.org/1999/xlink", "xlink:href", image.nodeName === "CANVAS" ? image.toDataURL() : image.getAttribute("src"));
+        pattern.appendChild(img);
+
+        this.__defs.appendChild(pattern);
+      } else if (image instanceof ctx) {
+        pattern.appendChild(image.__root.childNodes[1]);
+
+        this.__defs.appendChild(pattern);
+      }
+
+      return new CanvasPattern(pattern, this);
+    };
+
+    ctx.prototype.setLineDash = function (dashArray) {
+      if (dashArray && dashArray.length > 0) {
+        this.lineDash = dashArray.join(",");
+      } else {
+        this.lineDash = null;
+      }
+    };
+    /**
+     * Not yet implemented
+     */
+
+
+    ctx.prototype.drawFocusRing = function () {};
+
+    ctx.prototype.createImageData = function () {};
+
+    ctx.prototype.getImageData = function () {};
+
+    ctx.prototype.putImageData = function () {};
+
+    ctx.prototype.globalCompositeOperation = function () {};
+
+    ctx.prototype.setTransform = function () {};
+
+    var C2S = ctx;
+
+    /**
+     * Created by dat on 9/16/16.
+     */
+    const NOT_LOADED_MESSAGE = 'Error loading track data';
+
+    class ViewPort extends ViewportBase {
+      constructor(trackView, $viewportContainer, referenceFrame, width) {
+        super(trackView, $viewportContainer, referenceFrame, width);
+      }
+
+      initializationHelper() {
+        this.menuPopup = new MenuPopup(this.trackView.$viewportContainer);
+        this.menuPopup.$popover.hide();
+        this.addMouseHandlers();
+        this.$spinner = $('<div class="igv-viewport-spinner">');
+        this.$spinner.append(createIcon$1("spinner"));
+        this.$viewport.append(this.$spinner);
+        this.stopSpinner();
+        const {
+          track
+        } = this.trackView;
+
+        if ('sequence' !== track.type) {
+          this.$zoomInNotice = this.createZoomInNotice(this.$content);
+        }
+
+        if (track.name && "sequence" !== track.config.type) {
+          this.$trackLabel = $('<div class="igv-track-label">');
+          this.$viewport.append(this.$trackLabel);
+          this.setTrackLabel(track.name);
+
+          if (false === this.browser.trackLabelsVisible) {
+            this.$trackLabel.hide();
+          }
+
+          this.$trackLabel.click(e => {
+            let str;
+            e.stopPropagation();
+
+            if (typeof track.description === 'function') {
+              str = track.description();
+            } else if (track.description) {
+              str = `<div>${track.description}</div>`;
+            } else {
+              if (track.url) {
+                if (track.url instanceof File) {
+                  str = `<div><b>Filename: </b>${track.url.name}`;
+                } else {
+                  str = `<div><b>URL: </b>${track.url}`;
+                }
+              } else {
+                str = track.name;
+              }
+            }
+
+            if (this.popover) this.popover.dispose();
+            this.popover = new Popover(this.trackView.$viewportContainer.get(0), track.name || 'unnamed');
+            this.popover.presentContentWithEvent(e, str);
+          });
+          this.$trackLabel.mousedown(function (e) {
+            // Prevent bubbling
+            e.stopPropagation();
+          });
+          this.$trackLabel.mouseup(function (e) {
+            // Prevent  bubbling
+            e.stopPropagation();
+          });
+          this.$trackLabel.mousemove(function (e) {
+            // Prevent  bubbling
+            e.stopPropagation();
+          });
+        }
+      }
+
+      setTrackLabel(label) {
+        this.trackView.track.name = this.trackView.track.config.name = label;
+        this.$trackLabel.empty();
+        this.$trackLabel.html(label);
+        const txt = this.$trackLabel.text();
+        this.$trackLabel.attr('title', txt);
+      }
+
+      startSpinner() {
+        const $spinner = this.$spinner;
+
+        if ($spinner) {
+          $spinner.addClass("igv-fa5-spin");
+          $spinner.show();
+        }
+      }
+
+      stopSpinner() {
+        const $spinner = this.$spinner;
+
+        if ($spinner) {
+          $spinner.hide();
+          $spinner.removeClass("igv-fa5-spin");
+        }
+      }
+
+      checkZoomIn() {
+        const showZoomInNotice = () => {
+          const referenceFrame = this.referenceFrame;
+
+          if (this.referenceFrame.chr.toLowerCase() === "all" && !this.trackView.track.supportsWholeGenome()) {
+            return true;
+          } else {
+            const visibilityWindow = typeof this.trackView.track.getVisibilityWindow === 'function' ? this.trackView.track.getVisibilityWindow() : this.trackView.track.visibilityWindow;
+            return visibilityWindow !== undefined && visibilityWindow > 0 && referenceFrame.bpPerPixel * this.$viewport.width() > visibilityWindow;
+          }
+        };
+
+        if (!this.viewIsReady()) {
+          return false;
+        }
+
+        if (this.$zoomInNotice) {
+          if (showZoomInNotice()) {
+            // Out of visibility window
+            if (this.canvas) {
+              this.ctx.clearRect(0, 0, this.canvas.width, this.canvas.height);
+              this.tile = undefined;
+            }
+
+            this.$zoomInNotice.show();
+
+            if (this.trackView.track.autoHeight) {
+              const minHeight = this.trackView.minHeight || 0;
+              this.setContentHeight(minHeight);
+            }
+
+            return false;
+          } else {
+            this.$zoomInNotice.hide();
+            return true;
+          }
+        }
+
+        return true;
+      }
+
+      shift() {
+        const self = this;
+        const referenceFrame = self.referenceFrame;
+
+        if (self.canvas && self.tile && self.tile.chr === self.referenceFrame.chr && self.tile.bpPerPixel === referenceFrame.bpPerPixel) {
+          const pixelOffset = Math.round((self.tile.startBP - referenceFrame.start) / referenceFrame.bpPerPixel);
+          self.canvas.style.left = pixelOffset + "px";
+        }
+      }
+
+      async loadFeatures() {
+        const referenceFrame = this.referenceFrame;
+        const chr = referenceFrame.chr; // Expand the requested range so we can pan a bit without reloading.  But not beyond chromosome bounds
+
+        const chrLength = this.browser.genome.getChromosome(chr).bpLength;
+        const pixelWidth = this.$content.width() * 3;
+        const bpWidth = pixelWidth * referenceFrame.bpPerPixel;
+        const bpStart = Math.floor(Math.max(0, referenceFrame.start - bpWidth / 3));
+        const bpEnd = Math.ceil(Math.min(chrLength, bpStart + bpWidth));
+
+        if (this.loading && this.loading.start === bpStart && this.loading.end === bpEnd) {
+          return undefined;
+        }
+
+        this.loading = {
+          start: bpStart,
+          end: bpEnd
+        };
+        this.startSpinner(); // console.log('get features');
+
+        try {
+          const features = await this.getFeatures(this.trackView.track, chr, bpStart, bpEnd, referenceFrame.bpPerPixel);
+          let roiFeatures = [];
+          const roi = mergeArrays(this.browser.roi, this.trackView.track.roi);
+
+          if (roi) {
+            for (let r of roi) {
+              const f = await r.getFeatures(chr, bpStart, bpEnd, referenceFrame.bpPerPixel);
+              roiFeatures.push({
+                track: r,
+                features: f
+              });
+            }
+          }
+
+          this.tile = new Tile(chr, bpStart, bpEnd, referenceFrame.bpPerPixel, features, roiFeatures);
+          this.loading = false;
+          this.hideMessage();
+          this.stopSpinner();
+          return this.tile;
+        } catch (error) {
+          // Track might have been removed during load
+          if (this.trackView && this.trackView.disposed !== true) {
+            this.showMessage(NOT_LOADED_MESSAGE);
+            Alert.presentAlert(error);
+            console.error(error);
+          }
+        } finally {
+          this.loading = false;
+          this.stopSpinner();
+        }
+      }
+
+      async repaint() {
+        if (undefined === this.tile) {
+          return;
+        }
+
+        let {
+          features,
+          roiFeatures,
+          bpPerPixel,
+          startBP,
+          endBP
+        } = this.tile;
+        const isWGV = GenomeUtils.isWholeGenomeView(this.browser.referenceFrameList[0].chr);
+        let pixelWidth;
+
+        if (isWGV) {
+          bpPerPixel = this.referenceFrame.initialEnd / this.$viewport.width();
+          startBP = 0;
+          endBP = this.referenceFrame.initialEnd;
+          pixelWidth = this.$viewport.width();
+        } else {
+          pixelWidth = Math.ceil((endBP - startBP) / bpPerPixel);
+        } // For deep tracks we paint a canvas == 3*viewportHeight centered on the current vertical scroll position
+
+
+        const viewportHeight = this.$viewport.height();
+        const contentHeight = this.getContentHeight();
+        const minHeight = roiFeatures ? Math.max(contentHeight, viewportHeight) : contentHeight; // Need to fill viewport for ROIs.
+
+        let pixelHeight = Math.min(minHeight, 3 * viewportHeight);
+
+        if (0 === pixelWidth || 0 === pixelHeight) {
+          if (this.canvas) {
+            $(this.canvas).remove();
+          }
+
+          return;
+        }
+
+        const canvasTop = Math.max(0, -this.$content.position().top - viewportHeight); // Always use high DPI if in compressed display mode, otherwise use preference setting;
+
+        let devicePixelRatio;
+
+        if ("FILL" === this.trackView.track.displayMode) {
+          devicePixelRatio = window.devicePixelRatio;
+        } else {
+          devicePixelRatio = this.trackView.track.supportHiDPI === false ? 1 : window.devicePixelRatio;
+        }
+
+        const pixelXOffset = Math.round((startBP - this.referenceFrame.start) / this.referenceFrame.bpPerPixel);
+        const newCanvas = $('<canvas class="igv-canvas">').get(0);
+        const ctx = newCanvas.getContext("2d");
+        newCanvas.style.width = pixelWidth + "px";
+        newCanvas.style.height = pixelHeight + "px";
+        newCanvas.width = devicePixelRatio * pixelWidth;
+        newCanvas.height = devicePixelRatio * pixelHeight;
+        ctx.scale(devicePixelRatio, devicePixelRatio);
+        newCanvas.style.left = pixelXOffset + "px";
+        newCanvas.style.top = canvasTop + "px";
+        ctx.translate(0, -canvasTop);
+        const drawConfiguration = {
+          context: ctx,
+          pixelXOffset,
+          pixelWidth,
+          pixelHeight,
+          pixelTop: canvasTop,
+          bpStart: startBP,
+          bpEnd: endBP,
+          bpPerPixel,
+          referenceFrame: this.referenceFrame,
+          selection: this.selection,
+          viewport: this,
+          viewportWidth: this.$viewport.width() //viewportContainerX: this.referenceFrame.toPixels(this.referenceFrame.start - startBP),
+          //viewportContainerWidth: this.browser.getViewportContainerWidth()
+
+        };
+        this.draw(drawConfiguration, features, roiFeatures);
+        this.canvasVerticalRange = {
+          top: canvasTop,
+          bottom: canvasTop + pixelHeight
+        };
+
+        if (this.$canvas) {
+          this.$canvas.remove();
+        }
+
+        this.$canvas = $(newCanvas);
+        this.$content.append(this.$canvas);
+        this.canvas = newCanvas;
+        this.ctx = ctx;
+      }
+
+      draw(drawConfiguration, features, roiFeatures) {
+        // console.log(`${ Date.now() } viewport draw(). track ${ this.trackView.track.type }. content-css-top ${ this.$content.css('top') }. canvas-top ${ drawConfiguration.pixelTop }.`)
+        if (features) {
+          drawConfiguration.features = features;
+          this.trackView.track.draw(drawConfiguration);
+        }
+
+        if (roiFeatures) {
+          for (let r of roiFeatures) {
+            drawConfiguration.features = r.features;
+            r.track.draw(drawConfiguration);
+          }
+        }
+      } // TODO: Nolonger used. Will discard
+
+
+      async toSVG(tile) {
+        // Nothing to do if zoomInNotice is active
+        if (this.$zoomInNotice && this.$zoomInNotice.is(":visible")) {
+          return;
+        }
+
+        const referenceFrame = this.referenceFrame;
+        const bpPerPixel = tile.bpPerPixel;
+        const features = tile.features;
+        const roiFeatures = tile.roiFeatures;
+        const pixelWidth = this.$viewport.width();
+        const pixelHeight = this.$viewport.height();
+        const bpStart = referenceFrame.start;
+        const bpEnd = referenceFrame.start + pixelWidth * referenceFrame.bpPerPixel;
+        const ctx = new C2S({
+          // svg
+          width: pixelWidth,
+          height: pixelHeight,
+          viewbox: {
+            x: 0,
+            y: -this.$content.position().top,
+            width: pixelWidth,
+            height: pixelHeight
+          }
+        });
+        const drawConfiguration = {
+          viewport: this,
+          context: ctx,
+          top: -this.$content.position().top,
+          pixelTop: 0,
+          // for compatibility with canvas draw
+          pixelWidth,
+          pixelHeight,
+          bpStart,
+          bpEnd,
+          bpPerPixel,
+          referenceFrame: this.referenceFrame,
+          selection: this.selection,
+          viewportWidth: pixelWidth,
+          viewportContainerX: 0,
+          viewportContainerWidth: this.browser.getViewportContainerWidth()
+        };
+        this.draw(drawConfiguration, features, roiFeatures);
+        return ctx.getSerializedSvg(true);
+      }
+
+      containsPosition(chr, position) {
+        if (this.referenceFrame.chr === chr && position >= this.referenceFrame.start) {
+          return position <= this.referenceFrame.calculateEnd(this.getWidth());
+        } else {
+          return false;
+        }
+      }
+
+      isLoading() {
+        return this.loading;
+      }
+
+      saveImage() {
+        if (!this.ctx) return;
+        const canvasTop = this.canvasVerticalRange ? this.canvasVerticalRange.top : 0;
+        const devicePixelRatio = window.devicePixelRatio;
+        const w = this.$viewport.width() * devicePixelRatio;
+        const h = this.$viewport.height() * devicePixelRatio;
+        const x = -$(this.canvas).position().left * devicePixelRatio;
+        const y = (-this.$content.position().top - canvasTop) * devicePixelRatio;
+        const imageData = this.ctx.getImageData(x, y, w, h);
+        const exportCanvas = document.createElement('canvas');
+        const exportCtx = exportCanvas.getContext('2d');
+        exportCanvas.width = imageData.width;
+        exportCanvas.height = imageData.height;
+        exportCtx.putImageData(imageData, 0, 0); // filename = this.trackView.track.name + ".png";
+
+        const filename = (this.$trackLabel.text() ? this.$trackLabel.text() : "image") + ".png";
+        const data = exportCanvas.toDataURL("image/png");
+        download(filename, data);
+      }
+
+      saveSVG() {
+        const {
+          width,
+          height
+        } = this.$viewport.get(0).getBoundingClientRect();
+        const config = {
+          width,
+          height,
+          viewbox: {
+            x: 0,
+            y: -this.$content.position().top,
+            width,
+            height
+          }
+        };
+        const context = new C2S(config);
+        const str = (this.trackView.track.name || this.trackView.track.id).replace(/\W/g, '');
+        const index = this.browser.referenceFrameList.indexOf(this.referenceFrame);
+        const id = `${str}_referenceFrame_${index}_guid_${guid()}`;
+        this.drawSVGWithContext(context, width, height, id, 0, 0, 0);
+        const svg = context.getSerializedSvg(true);
+        const data = URL.createObjectURL(new Blob([svg], {
+          type: "application/octet-stream"
+        }));
+        download(`${id}.svg`, data);
+      } // called by trackView.renderSVGContext() when rendering
+      // entire browser as SVG
+
+
+      renderSVGContext(context, {
+        deltaX,
+        deltaY
+      }) {
+        // Nothing to do if zoomInNotice is active
+        if (this.$zoomInNotice && this.$zoomInNotice.is(":visible")) {
+          return;
+        }
+
+        const str = (this.trackView.track.name || this.trackView.track.id).replace(/\W/g, '');
+        const index = this.browser.referenceFrameList.indexOf(this.referenceFrame);
+        const id = `${str}_referenceFrame_${index}_guid_${guid()}`;
+        const yScrollDelta = $(this.contentDiv).position().top;
+        const dx = deltaX + index * context.multiLocusGap;
+        const dy = deltaY + yScrollDelta;
+        const {
+          width,
+          height
+        } = this.$viewport.get(0).getBoundingClientRect();
+        this.drawSVGWithContext(context, width, height, id, dx, dy, -yScrollDelta);
+
+        if (this.$trackLabel && true === this.browser.trackLabelsVisible) {
+          const {
+            x: xTrackLabel,
+            y: yTrackLabel,
+            width: wTracklabel,
+            height: hTrackLabel
+          } = relativeDOMBBox(this.$viewport.get(0), this.$trackLabel.get(0));
+          this.renderTrackLabelSVG(context, deltaX + xTrackLabel, deltaY + yTrackLabel, wTracklabel, hTrackLabel);
+        }
+      } // render track label element called from renderSVGContext()
+
+
+      renderTrackLabelSVG(context, tx, ty, width, height) {
+        const str = (this.trackView.track.name || this.trackView.track.id).replace(/\W/g, '');
+        const id = `${str}_track_label_guid_${guid()}`;
+        context.saveWithTranslationAndClipRect(id, tx, ty, width, height, 0);
+        context.fillStyle = "white";
+        context.fillRect(0, 0, width, height);
+        context.font = "12px Arial";
+        context.fillStyle = 'rgb(68, 68, 68)';
+        const {
+          width: stringWidth
+        } = context.measureText(this.$trackLabel.text());
+        const dx = 0.25 * (width - stringWidth);
+        const dy = 0.7 * (height - 12);
+        context.fillText(this.$trackLabel.text(), dx, height - dy);
+        context.strokeStyle = 'rgb(68, 68, 68)';
+        context.strokeRect(0, 0, width, height);
+        context.restore();
+      } // called by renderSVGContext()
+
+
+      drawSVGWithContext(context, width, height, id, tx, ty, clipYOffset) {
+        let {
+          start,
+          bpPerPixel
+        } = this.referenceFrame;
+        context.saveWithTranslationAndClipRect(id, tx, ty, width, height, clipYOffset);
+        const top = -this.$content.position().top;
+        const config = {
+          context,
+          viewport: this,
+          referenceFrame: this.referenceFrame,
+          top,
+          pixelTop: top,
+          pixelWidth: width,
+          pixelHeight: height,
+          bpStart: start,
+          bpEnd: start + width * bpPerPixel,
+          bpPerPixel,
+          viewportWidth: width,
+          // viewportContainerX: 0,
+          // viewportContainerWidth: this.browser.getViewportContainerWidth(),
+          selection: this.selection
+        };
+        const features = this.tile ? this.tile.features : [];
+        const roiFeatures = this.tile ? this.tile.roiFeatures : undefined;
+        this.draw(config, features, roiFeatures);
+        context.restore();
+      }
+
+      getCachedFeatures() {
+        return this.tile ? this.tile.features : [];
+      }
+
+      async getFeatures(track, chr, start, end, bpPerPixel) {
+        if (this.tile && this.tile.containsRange(chr, start, end, bpPerPixel)) {
+          return this.tile.features;
+        } else if (typeof track.getFeatures === "function") {
+          const features = await track.getFeatures(chr, start, end, bpPerPixel, this);
+          this.cachedFeatures = features;
+          this.checkContentHeight();
+          return features;
+        } else {
+          return undefined;
+        }
+      }
+
+      createZoomInNotice($parent) {
+        const $notice = $('<div class="zoom-in-notice-container">');
+        $parent.append($notice);
+        const $e = $('<div>');
+        $notice.append($e);
+        $e.text('Zoom in to see features');
+        $notice.hide();
+        return $notice;
+      }
+
+      viewIsReady() {
+        return this.browser && this.browser.referenceFrameList && this.referenceFrame;
+      }
+
+      addMouseHandlers() {
+        const self = this;
+        const browser = this.browser;
+        let popupTimerID;
+        let lastClickTime = 0;
+        this.$viewport.on("contextmenu", function (e) {
+          // Ignore if we are doing a drag.  This can happen with touch events.
+          if (self.browser.dragObject) {
+            return false;
+          }
+
+          const clickState = createClickState(e, self);
+
+          if (undefined === clickState) {
+            return false;
+          }
+
+          e.preventDefault(); // Track specific items
+
+          let menuItems = [];
+
+          if (typeof self.trackView.track.contextMenuItemList === "function") {
+            const trackMenuItems = self.trackView.track.contextMenuItemList(clickState);
+
+            if (trackMenuItems) {
+              menuItems = trackMenuItems;
+            }
+          } // Add items common to all tracks
+
+
+          if (menuItems.length > 0) {
+            menuItems.push({
+              label: $('<HR>')
+            });
+          }
+
+          menuItems.push({
+            label: 'Save Image (PNG)',
+            click: () => self.saveImage()
+          });
+          menuItems.push({
+            label: 'Save Image (SVG)',
+            click: () => self.saveSVG()
+          });
+          self.menuPopup.presentTrackContextMenu(e, menuItems);
+        });
+        /**
+         * Mouse click down,  notify browser for potential drag (pan), and record position for potential click.
+         */
+
+        this.$viewport.on('mousedown', function (e) {
+          self.enableClick = true;
+          browser.mouseDownOnViewport(e, self);
+          pageCoordinates$1(e);
+        });
+        this.$viewport.on('touchstart', function (e) {
+          self.enableClick = true;
+          browser.mouseDownOnViewport(e, self);
+          pageCoordinates$1(e);
+        });
+        /**
+         * Mouse is released.  Ignore if this is a context menu click, or the end of a drag action.   If neither of
+         * those, it is a click.
+         */
+
+        this.$viewport.on('mouseup', handleMouseUp);
+        this.$viewport.on('touchend', handleMouseUp);
+        this.$viewport.on('click', function (e) {
+          if (self.enableClick) {
+            handleClick(e);
+          }
+        });
+
+        function handleMouseUp(e) {
+          // Any mouse up cancels drag and scrolling
+          if (self.browser.dragObject || self.browser.isScrolling) {
+            self.browser.cancelTrackPan();
+            e.preventDefault();
+            e.stopPropagation();
+            self.enableClick = false; // Until next mouse down
+
+            return;
+          } else {
+            self.browser.cancelTrackPan();
+            self.browser.endTrackDrag();
+          }
+        }
+
+        function handleClick(e) {
+          if (3 === e.which || e.ctrlKey) {
+            return;
+          } // Close any currently open popups
+
+
+          $('.igv-popover').hide();
+
+          if (browser.dragObject || browser.isScrolling) {
+            return;
+          } // // Interpret mouseDown + mouseUp < 5 pixels as a click.
+          // if(!mouseDownCoords) {
+          //     return;
+          // }
+          // const coords = pageCoordinates(e);
+          // const dx = coords.x - mouseDownCoords.x;
+          // const dy = coords.y - mouseDownCoords.y;
+          // const dist2 = dx*dx + dy*dy;
+          // if(dist2 > 25) {
+          //     mouseDownCoords = undefined;
+          //     return;
+          // }
+          // Treat as a mouse click, its either a single or double click.
+          // Handle here and stop propogation / default
+
+
+          e.preventDefault();
+          e.stopPropagation();
+          const mouseX = translateMouseCoordinates$1(e, self.$viewport.get(0)).x;
+          const mouseXCanvas = translateMouseCoordinates$1(e, self.canvas).x;
+          const referenceFrame = self.referenceFrame;
+          const xBP = Math.floor(referenceFrame.start + referenceFrame.toBP(mouseXCanvas));
+          const time = Date.now();
+
+          if (time - lastClickTime < browser.constants.doubleClickDelay) {
+            // double-click
+            if (popupTimerID) {
+              window.clearTimeout(popupTimerID);
+              popupTimerID = undefined;
+            }
+
+            const centerBP = Math.round(referenceFrame.start + referenceFrame.toBP(mouseX));
+            let string;
+
+            if ('all' === self.referenceFrame.chr.toLowerCase()) {
+              const chr = browser.genome.getChromosomeCoordinate(centerBP).chr;
+
+              if (1 === browser.referenceFrameList.length) {
+                string = chr;
+              } else {
+                let loci = browser.referenceFrameList.map(function (g) {
+                  return g.locusSearchString;
+                });
+                loci[browser.referenceFrameList.indexOf(self.referenceFrame)] = chr;
+                string = loci.join(' ');
+              }
+
+              browser.search(string);
+            } else {
+              browser.zoomWithScaleFactor(0.5, centerBP, self);
+            }
+          } else {
+            // single-click
+            if (e.shiftKey && typeof self.trackView.track.shiftClick === "function") {
+              self.trackView.track.shiftClick(xBP, e);
+            } else if (typeof self.trackView.track.popupData === "function") {
+              popupTimerID = setTimeout(function () {
+                const content = getPopupContent(e, self);
+
+                if (content) {
+                  if (self.popover) self.popover.dispose();
+                  self.popover = new Popover(self.trackView.$viewportContainer.get(0));
+                  self.popover.presentContentWithEvent(e, content);
+                }
+
+                clearTimeout(popupTimerID);
+                popupTimerID = undefined;
+              }, browser.constants.doubleClickDelay);
+            }
+          }
+
+          lastClickTime = time;
+        }
+
+        function createClickState(e, viewport) {
+          const referenceFrame = viewport.referenceFrame;
+          const viewportCoords = translateMouseCoordinates$1(e, viewport.contentDiv);
+          const canvasCoords = translateMouseCoordinates$1(e, viewport.canvas);
+          const genomicLocation = referenceFrame.start + referenceFrame.toBP(viewportCoords.x);
+
+          if (undefined === genomicLocation || null === viewport.tile) {
+            return undefined;
+          }
+
+          return {
+            event: e,
+            viewport: viewport,
+            referenceFrame: referenceFrame,
+            genomicLocation: genomicLocation,
+            x: viewportCoords.x,
+            y: viewportCoords.y,
+            canvasX: canvasCoords.x,
+            canvasY: canvasCoords.y
+          };
+        }
+        /**
+         * Return markup for popup info window
+         *
+         * @param e
+         * @param viewport
+         * @returns {*}
+         */
+
+
+        function getPopupContent(e, viewport) {
+          const clickState = createClickState(e, viewport);
+
+          if (undefined === clickState) {
+            return;
+          }
+
+          let track = viewport.trackView.track;
+          const dataList = track.popupData(clickState);
+          const popupClickHandlerResult = browser.fireEvent('trackclick', [track, dataList]);
+          let content;
+
+          if (undefined === popupClickHandlerResult || true === popupClickHandlerResult) {
+            // Indicates handler did not handle the result, or the handler wishes default behavior to occur
+            if (dataList && dataList.length > 0) {
+              content = formatPopoverText(dataList);
+            }
+          } else if (typeof popupClickHandlerResult === 'string') {
+            content = popupClickHandlerResult;
+          }
+
+          return content;
+        }
+        /**
+         * Format markup for popover text from an array of name value pairs [{name, value}]
+         */
+
+
+        function formatPopoverText(nameValues) {
+          const rows = nameValues.map(nameValue => {
+            if (nameValue.name) {
+              const str = `<span>${nameValue.name}</span>&nbsp&nbsp&nbsp${nameValue.value}`;
+              return `<div title="${nameValue.value}">${str}</div>`;
+            } else if ('<hr>' === nameValue) {
+              // this can be retired if nameValue.html is allowed.
+              return nameValue;
+            } else if (nameValue.html) {
+              return nameValue.html;
+            } else {
+              return `<div title="${nameValue}">${nameValue}</div>`;
+            }
+          });
+          return rows.join('');
+        }
+      }
+
+    }
+
+    var Tile = function (chr, tileStart, tileEnd, bpPerPixel, features, roiFeatures) {
+      this.chr = chr;
+      this.startBP = tileStart;
+      this.endBP = tileEnd;
+      this.bpPerPixel = bpPerPixel;
+      this.features = features;
+      this.roiFeatures = roiFeatures;
+    };
+
+    Tile.prototype.containsRange = function (chr, start, end, bpPerPixel) {
+      return this.bpPerPixel === bpPerPixel && start >= this.startBP && end <= this.endBP && chr === this.chr;
+    };
+
+    Tile.prototype.overlapsRange = function (chr, start, end) {
+      return this.chr === chr && end >= this.startBP && start <= this.endBP;
+    };
+    /**
+     * Merge 2 arrays.  a and/or b can be undefined.  If both are undefined, return undefined
+     * @param a An array or undefined
+     * @param b An array or undefined
+     */
+
+
+    function mergeArrays(a, b) {
+      if (a && b) return a.concat(b);else if (a) return a;else return b;
+    }
+
+    /*
+     * The MIT License (MIT)
+     *
+     * Copyright (c) 2014 Broad Institute
+     *
+     * Permission is hereby granted, free of charge, to any person obtaining a copy
+     * of this software and associated documentation files (the "Software"), to deal
+     * in the Software without restriction, including without limitation the rights
+     * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+     * copies of the Software, and to permit persons to whom the Software is
+     * furnished to do so, subject to the following conditions:
+     *
+     * The above copyright notice and this permission notice shall be included in
+     * all copies or substantial portions of the Software.
+     *
+     *
+     * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+     * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+     * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+     * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+     * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+     * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+     * THE SOFTWARE.
+     */
+
+    class IdeogramViewport extends ViewPort {
+      constructor(trackView, $viewportContainer, referenceFrame, width) {
+        super(trackView, $viewportContainer, referenceFrame, width);
+      }
+
+      initializationHelper() {
+        this.$ideogramCanvas = $('<canvas>', {
+          class: 'igv-ideogram-canvas'
+        });
+        this.$ideogramCanvas.insertBefore(this.$canvas);
+        const canvas = this.$ideogramCanvas.get(0);
+        this.ideogram_ctx = canvas.getContext('2d');
+        this.$canvas.remove();
+        this.canvas = undefined;
+        this.ctx = undefined;
+        this.$viewport.on('click.ideogram', e => {
+          clickHandler(e, canvas, this.browser, this.referenceFrame);
+        });
+      }
+
+      setWidth(width) {
+        this.$viewport.width(width);
+      }
+
+      drawSVGWithContext(context, width, height, id, tx, ty, clipYOffset) {
+        context.saveWithTranslationAndClipRect(id, tx, ty, width, height, clipYOffset);
+        this.trackView.track.draw({
+          context,
+          referenceFrame: this.referenceFrame,
+          pixelWidth: width,
+          pixelHeight: height
+        });
+        context.restore();
+      }
+
+      async repaint() {
+        this.draw({
+          referenceFrame: this.referenceFrame
+        });
+      }
+
+      draw({
+        referenceFrame
+      }) {
+        this.$canvas.hide();
+        IGVGraphics.configureHighDPICanvas(this.ideogram_ctx, this.$viewport.width(), this.$viewport.height());
+        this.trackView.track.draw({
+          context: this.ideogram_ctx,
+          referenceFrame,
+          pixelWidth: this.$viewport.width(),
+          pixelHeight: this.$viewport.height()
+        });
+      }
+
+    }
+
+    function clickHandler(e, canvas, browser, referenceFrame) {
+      const {
+        xNormalized,
+        width
+      } = translateMouseCoordinates$1(e, canvas);
+      const {
+        bpLength
+      } = browser.genome.getChromosome(referenceFrame.chr);
+      const locusLength = referenceFrame.bpPerPixel * width;
+      const chrCoveragePercentage = locusLength / bpLength;
+      let xPercentage = xNormalized;
+
+      if (xPercentage - chrCoveragePercentage / 2.0 < 0) {
+        xPercentage = chrCoveragePercentage / 2.0;
+      }
+
+      if (xPercentage + chrCoveragePercentage / 2.0 > 1.0) {
+        xPercentage = 1.0 - chrCoveragePercentage / 2.0;
+      }
+
+      const ss = Math.round((xPercentage - chrCoveragePercentage / 2.0) * bpLength);
+      const ee = Math.round((xPercentage + chrCoveragePercentage / 2.0) * bpLength);
+      referenceFrame.start = ss;
+      referenceFrame.initialEnd = ee;
+      referenceFrame.bpPerPixel = (ee - ss) / width;
+      browser.updateLocusSearchWidget(browser.referenceFrameList > 1 ? browser.referenceFrameList : [referenceFrame]);
+      browser.updateViews(referenceFrame, browser.trackViews, true);
+    }
+
+    /*
+     * The MIT License (MIT)
+     *
+     * Copyright (c) 2016-2017 The Regents of the University of California
+     * Author: Jim Robinson
+     *
+     * Permission is hereby granted, free of charge, to any person obtaining a copy
+     * of this software and associated documentation files (the "Software"), to deal
+     * in the Software without restriction, including without limitation the rights
+     * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+     * copies of the Software, and to permit persons to whom the Software is
+     * furnished to do so, subject to the following conditions:
+     *
+     * The above copyright notice and this permission notice shall be included in
+     * all copies or substantial portions of the Software.
+     *
+     *
+     * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+     * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+     * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+     * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+     * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+     * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+     * THE SOFTWARE.
+     */
+
+    class RulerSweeper {
+      constructor(viewport) {
+        this.viewport = viewport;
+        this.browser = viewport.browser;
+        this.$rulerSweeper = $('<div class="igv-ruler-sweeper-div">');
+        $(viewport.contentDiv).append(this.$rulerSweeper);
+        this.namespace = '.sweeper_' + guid();
+        this.addMouseHandlers();
+      }
+
+      disableMouseHandlers() {
+        $(document).off(this.namespace);
+        this.viewport.$viewport.off(this.namespace);
+      }
+
+      addMouseHandlers() {
+        const browser = this.browser;
+        const self = this;
+        var isMouseDown, isMouseIn, mouseDown, left, threshold, width, dx;
+        this.disableMouseHandlers();
+        isMouseDown = isMouseIn = mouseDown = undefined;
+        threshold = 1;
+        $(this.browser.$root).on('mousedown' + this.namespace, function (e) {
+          isMouseIn = true;
+          mouseDown = translateMouseCoordinates$1(e, self.viewport.$viewport.get(0)).x;
+
+          if (true === isMouseDown) {
+            self.$rulerSweeper.show();
+            width = threshold;
+            left = mouseDown;
+            self.$rulerSweeper.css({
+              left: left + 'px'
+            });
+            self.$rulerSweeper.width(width);
+          }
+        });
+        $(this.browser.$root).on('mousemove' + this.namespace, function (e) {
+          var mouseCurrent;
+
+          if (isMouseDown && isMouseIn) {
+            mouseCurrent = translateMouseCoordinates$1(e, self.viewport.$viewport.get(0)).x;
+            mouseCurrent = Math.min(mouseCurrent, self.viewport.$viewport.width());
+            mouseCurrent = Math.max(mouseCurrent, 0);
+            dx = mouseCurrent - mouseDown;
+            width = Math.abs(dx);
+            self.$rulerSweeper.width(width);
+
+            if (dx < 0) {
+              left = mouseDown + dx;
+              self.$rulerSweeper.css({
+                left: left + 'px'
+              });
+            }
+          }
+        });
+        $(this.browser.$root).on('mouseup' + this.namespace, function (e) {
+          let extent;
+
+          if (true === isMouseDown && true === isMouseIn) {
+            isMouseDown = isMouseIn = undefined;
+            self.$rulerSweeper.hide();
+            extent = {};
+            extent.start = self.bp(left);
+            extent.end = self.bp(left + width);
+
+            if (width > threshold) {
+              validateLocusExtent(browser.genome.getChromosome(self.viewport.referenceFrame.chr).bpLength, extent, browser.minimumBases());
+              self.viewport.referenceFrame.bpPerPixel = (Math.round(extent.end) - Math.round(extent.start)) / self.viewport.$viewport.width();
+              self.viewport.referenceFrame.start = Math.round(extent.start);
+              self.viewport.referenceFrame.initialEnd = Math.round(extent.end);
+              browser.updateViews(self.viewport.referenceFrame);
+            }
+          }
+        });
+        this.viewport.$viewport.on('mousedown' + this.namespace, function (e) {
+          isMouseDown = true;
+        });
+      }
+
+      dispose() {
+        this.disableMouseHandlers();
+      }
+
+      bp(pixel) {
+        return this.viewport.referenceFrame.start + pixel * this.viewport.referenceFrame.bpPerPixel;
+      }
+
+    }
+
+    let timer;
+    let currentViewport = undefined;
+    const toolTipTimeout = 1e4;
+
+    class RulerViewport extends ViewPort {
+      constructor(trackView, $viewportContainer, referenceFrame, width) {
+        super(trackView, $viewportContainer, referenceFrame, width);
+      }
+
+      initializationHelper() {
+        this.rulerSweeper = new RulerSweeper(this);
+        appendMultiPanelCloseButton(this.browser, this.$viewport, this.referenceFrame);
+        this.$rulerLabel = $('<div class = "igv-multi-locus-panel-label-div">');
+        this.$content.append(this.$rulerLabel);
+        this.$rulerLabel.click(() => this.browser.selectMultiLocusPanelWithReferenceFrame(this.referenceFrame));
+        this.$tooltip = $('<div>', {
+          class: 'igv-ruler-tooltip'
+        });
+        this.$tooltip.height(this.$viewport.height());
+        this.$viewport.append(this.$tooltip);
+        this.$tooltipContent = $('<div>');
+        this.$tooltip.append(this.$tooltipContent);
+        this.attachMouseHandlers(GenomeUtils.isWholeGenomeView(this.browser.referenceFrameList[0].chr));
+        this.$tooltip.hide();
+      }
+
+      updateLocusLabel() {
+        const str = this.referenceFrame.presentLocus(this.$viewport.width());
+        this.$rulerLabel.text(str);
+      }
+
+      attachMouseHandlers(isWholeGenomeView) {
+        this.namespace = `.ruler_track_viewport_${this.browser.referenceFrameList.indexOf(this.referenceFrame)}`;
+        this.$viewport.off(this.namespace);
+
+        if (true === isWholeGenomeView) {
+          const index = this.browser.referenceFrameList.indexOf(this.referenceFrame);
+          const click = `click${this.namespace}`;
+          this.$viewport.on(click, e => {
+            const {
+              x: pixel
+            } = translateMouseCoordinates$1(e, this.$viewport.get(0));
+            const bp = Math.round(this.referenceFrame.start + this.referenceFrame.toBP(pixel));
+            let searchString;
+            const {
+              chr
+            } = this.browser.genome.getChromosomeCoordinate(bp);
+
+            if (1 === this.browser.referenceFrameList.length) {
+              searchString = chr;
+            } else {
+              let loci = this.browser.referenceFrameList.map(({
+                locusSearchString
+              }) => locusSearchString);
+              loci[index] = chr;
+              searchString = loci.join(' ');
+            }
+
+            this.browser.search(searchString);
+          });
+        }
+      }
+
+      mouseMove(event) {
+        if (true === this.browser.cursorGuideVisible) {
+          if (undefined === currentViewport) {
+            currentViewport = this;
+            this.$tooltip.show();
+          } else if (currentViewport.guid !== this.guid) {
+            currentViewport.$tooltip.hide();
+            this.$tooltip.show();
+            currentViewport = this;
+          } else {
+            this.$tooltip.show();
+          }
+
+          const isWholeGenome = this.browser.isMultiLocusWholeGenomeView() || GenomeUtils.isWholeGenomeView(this.browser.referenceFrameList[0].chr);
+
+          if (isWholeGenome) {
+            this.$tooltip.hide();
+            return;
+          }
+
+          const {
+            x
+          } = translateMouseCoordinates$1(event, this.$viewport.get(0));
+          const {
+            start,
+            bpPerPixel
+          } = this.referenceFrame;
+          const bp = Math.round(0.5 + start + Math.max(0, x) * bpPerPixel);
+          this.$tooltipContent.text(numberFormatter$1(bp));
+          const {
+            width: ww
+          } = this.$tooltipContent.get(0).getBoundingClientRect();
+          const {
+            width: w
+          } = this.$viewport.get(0).getBoundingClientRect();
+          this.$tooltip.css({
+            left: `${IGVMath.clamp(x, 0, w - ww)}px`
+          }); // hide tooltip when movement stops
+
+          clearTimeout(timer);
+          timer = setTimeout(() => this.$tooltip.hide(), toolTipTimeout);
+        }
+      }
+
+    }
+
+    function appendMultiPanelCloseButton(browser, $viewport, referenceFrame) {
+      $viewport.addClass('igv-viewport-ruler');
+      const $close = $('<div class="igv-multi-locus-panel-close-container">');
+      $viewport.append($close);
+      $close.append(createIcon$1("times-circle"));
+      $close.click(() => browser.removeMultiLocusPanelWithReferenceFrame(referenceFrame, true));
+    }
+
+    const createViewport = (trackView, referenceFrameList, index, width) => {
+      if ('ruler' === trackView.track.type) {
+        return new RulerViewport(trackView, trackView.$viewportContainer, referenceFrameList[index], width);
+      } else if ('ideogram' === trackView.track.type) {
+        return new IdeogramViewport(trackView, trackView.$viewportContainer, referenceFrameList[index], width);
+      } else {
+        return new ViewPort(trackView, trackView.$viewportContainer, referenceFrameList[index], width);
+      }
+    };
+
+    /*
+     * The MIT License (MIT)
+     *
+     * Copyright (c) 2014 Broad Institute
+     *
+     * Permission is hereby granted, free of charge, to any person obtaining a copy
+     * of this software and associated documentation files (the "Software"), to deal
+     * in the Software without restriction, including without limitation the rights
+     * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+     * copies of the Software, and to permit persons to whom the Software is
+     * furnished to do so, subject to the following conditions:
+     *
+     * The above copyright notice and this permission notice shall be included in
+     * all copies or substantial portions of the Software.
+     *
+     *
+     * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+     * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+     * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+     * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+     * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+     * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+     * THE SOFTWARE.
+     */
+    const numberFormatter = numberFormatter$1;
+
+    class RulerTrack {
+      constructor(browser) {
+        this.browser = browser;
+        this.height = 40;
+        this.name = "";
+        this.id = "ruler";
+        this.disableButtons = true;
+        this.ignoreTrackMenu = true;
+        this.order = Number.MIN_SAFE_INTEGER * 1e-2;
+        this.removable = false;
+        this.type = 'ruler';
+      }
+
+      updateLocusLabel() {
+        for (let viewport of this.trackView.viewports) {
+          viewport.updateLocusLabel();
+        }
+      }
+
+      async getFeatures(chr, start, end) {
+        return [];
+      }
+
+      computePixelHeight(ignore) {
+        return this.height;
+      }
+
+      draw(options) {
+        if (GenomeUtils.isWholeGenomeView(options.referenceFrame.chr)) {
+          options.viewport.rulerSweeper.disableMouseHandlers();
+          this.drawWholeGenome(options);
+        } else {
+          options.viewport.rulerSweeper.addMouseHandlers();
+          const tickHeight = 6;
+          const shim = 2;
+          const pixelWidthBP = 1 + Math.floor(options.referenceFrame.toBP(options.pixelWidth));
+          const tick = new Tick(pixelWidthBP, options);
+          tick.drawTicks(options, tickHeight, shim, this.height);
+          IGVGraphics.strokeLine(options.context, 0, this.height - shim, options.pixelWidth, this.height - shim);
+        }
+      }
+
+      drawWholeGenome(options) {
+        options.context.save();
+        IGVGraphics.fillRect(options.context, 0, 0, options.pixelWidth, options.pixelHeight, {
+          'fillStyle': 'white'
+        });
+        let y = 0;
+        let h = options.pixelHeight;
+
+        for (let name of this.browser.genome.wgChromosomeNames) {
+          let xBP = this.browser.genome.getCumulativeOffset(name);
+          let wBP = this.browser.genome.getChromosome(name).bpLength;
+          let x = Math.round(xBP / options.bpPerPixel);
+          let w = Math.round(wBP / options.bpPerPixel);
+          this.renderChromosomeRect(options.context, x, y, w, h, name);
+        }
+
+        options.context.restore();
+      }
+
+      renderChromosomeRect(ctx, x, y, w, h, name) {
+        ctx.textAlign = 'center';
+        ctx.textBaseline = 'middle';
+        ctx.font = '12px sans-serif'; // IGVGraphics.fillRect(ctx, x, y, w, h, { 'fillStyle' : toggleColor(this.browser.genome.wgChromosomeNames.indexOf(name)) });
+
+        IGVGraphics.strokeLine(ctx, x + w, y, x + w, y + h, {
+          strokeStyle: IGVColor.greyScale(191)
+        });
+        const shortName = name.startsWith("chr") ? name.substring(3) : name;
+
+        if (w > ctx.measureText(shortName).width) {
+          IGVGraphics.fillText(ctx, shortName, x + w / 2, y + h / 2, {
+            fillStyle: IGVColor.greyScale(68)
+          });
+        }
+      }
+
+      supportsWholeGenome() {
+        return true;
+      }
+
+      dispose() {// do stuff
+      }
+
+    }
+
+    class Tick {
+      constructor(pixelWidthBP, options) {
+        initialize.call(this, pixelWidthBP, options);
+
+        function initialize(pixelWidthBP, options) {
+          var numberOfZeroes, majorUnit, unitMultiplier, numberOfMajorTicks, str;
+          const isSVGContext = options.context.isSVG || false;
+
+          if (pixelWidthBP < 10) {
+            set.call(this, 1, "bp", 1, isSVGContext);
+          }
+
+          numberOfZeroes = Math.floor(Math.log10(pixelWidthBP));
+
+          if (numberOfZeroes > 9) {
+            majorUnit = "gb";
+            unitMultiplier = 1e9;
+          } else if (numberOfZeroes > 6) {
+            majorUnit = "mb";
+            unitMultiplier = 1e6;
+          } else if (numberOfZeroes > 3) {
+            majorUnit = "kb";
+            unitMultiplier = 1e3;
+          } else {
+            majorUnit = "bp";
+            unitMultiplier = 1;
+          }
+
+          str = numberFormatter(Math.floor(pixelWidthBP / unitMultiplier)) + " " + majorUnit;
+          this.labelWidthBP = Math.round(options.referenceFrame.toBP(options.context.measureText(str).width));
+          numberOfMajorTicks = pixelWidthBP / Math.pow(10, numberOfZeroes - 1);
+
+          if (numberOfMajorTicks < 25) {
+            set.call(this, Math.pow(10, numberOfZeroes - 1), majorUnit, unitMultiplier, isSVGContext);
+          } else {
+            set.call(this, Math.pow(10, numberOfZeroes) / 2, majorUnit, unitMultiplier, isSVGContext);
+          }
+        }
+
+        function set(majorTick, majorUnit, unitMultiplier, isSVGContext) {
+          // reduce label frequency by half for SVG rendering
+          this.majorTick = true === isSVGContext ? 2 * majorTick : majorTick;
+          this.majorUnit = majorUnit;
+          this.halfTick = majorTick / 2;
+          this.unitMultiplier = unitMultiplier;
+        }
+      }
+
+      drawTicks(options, tickHeight, shim, height) {
+        var numberOfTicks, bp, pixel, label, labelWidth, labelX, numer, floored;
+        numberOfTicks = Math.floor(options.bpStart / this.majorTick) - 1;
+        labelWidth = 0;
+        labelX = 0;
+        pixel = 0;
+
+        while (pixel < options.pixelWidth) {
+          bp = Math.floor(numberOfTicks * this.majorTick);
+          pixel = Math.round(options.referenceFrame.toPixels(bp - 1 - options.bpStart + 0.5));
+          label = numberFormatter(Math.floor(bp / this.unitMultiplier)) + " " + this.majorUnit;
+          labelWidth = options.context.measureText(label).width;
+          labelX = Math.round(pixel - labelWidth / 2);
+          IGVGraphics.fillText(options.context, label, labelX, height - tickHeight / 0.75);
+          IGVGraphics.strokeLine(options.context, pixel, height - tickHeight, pixel, height - shim);
+          ++numberOfTicks;
+        }
+
+        numberOfTicks = Math.floor(options.bpStart / this.halfTick) - 1;
+        pixel = 0;
+
+        while (pixel < options.pixelWidth) {
+          bp = Math.floor(numberOfTicks * this.halfTick);
+          pixel = Math.round(options.referenceFrame.toPixels(bp - 1 - options.bpStart + 0.5));
+          numer = bp / this.unitMultiplier;
+          floored = Math.floor(numer);
+
+          if (numer === floored && this.majorTick / this.labelWidthBP > 8) {
+            label = numberFormatter(Math.floor(numer)) + " " + this.majorUnit;
+            labelWidth = options.context.measureText(label).width;
+            labelX = pixel - labelWidth / 2;
+            IGVGraphics.fillText(options.context, label, labelX, height - tickHeight / 0.75);
+          }
+
+          IGVGraphics.strokeLine(options.context, pixel, height - tickHeight, pixel, height - shim);
+          ++numberOfTicks;
+        }
+      }
+
+      description(blurb) {}
+
+    }
+
+    const appleCrayonRGBPalette = {
+      cantaloupe: {
+        r: 255,
+        g: 206,
+        b: 110
+      },
+      honeydew: {
+        r: 206,
+        g: 250,
+        b: 110
+      },
+      spindrift: {
+        r: 104,
+        g: 251,
+        b: 208
+      },
+      sky: {
+        r: 106,
+        g: 207,
+        b: 255
+      },
+      lavender: {
+        r: 210,
+        g: 120,
+        b: 255
+      },
+      carnation: {
+        r: 255,
+        g: 127,
+        b: 211
+      },
+      licorice: {
+        r: 0,
+        g: 0,
+        b: 0
+      },
+      snow: {
+        r: 255,
+        g: 255,
+        b: 255
+      },
+      salmon: {
+        r: 255,
+        g: 114,
+        b: 110
+      },
+      banana: {
+        r: 255,
+        g: 251,
+        b: 109
+      },
+      flora: {
+        r: 104,
+        g: 249,
+        b: 110
+      },
+      ice: {
+        r: 104,
+        g: 253,
+        b: 255
+      },
+      orchid: {
+        r: 110,
+        g: 118,
+        b: 255
+      },
+      bubblegum: {
+        r: 255,
+        g: 122,
+        b: 255
+      },
+      lead: {
+        r: 30,
+        g: 30,
+        b: 30
+      },
+      mercury: {
+        r: 232,
+        g: 232,
+        b: 232
+      },
+      tangerine: {
+        r: 255,
+        g: 136,
+        b: 2
+      },
+      lime: {
+        r: 131,
+        g: 249,
+        b: 2
+      },
+      sea_foam: {
+        r: 3,
+        g: 249,
+        b: 135
+      },
+      aqua: {
+        r: 0,
+        g: 140,
+        b: 255
+      },
+      grape: {
+        r: 137,
+        g: 49,
+        b: 255
+      },
+      strawberry: {
+        r: 255,
+        g: 41,
+        b: 135
+      },
+      tungsten: {
+        r: 58,
+        g: 58,
+        b: 58
+      },
+      silver: {
+        r: 208,
+        g: 208,
+        b: 208
+      },
+      maraschino: {
+        r: 255,
+        g: 33,
+        b: 1
+      },
+      lemon: {
+        r: 255,
+        g: 250,
+        b: 3
+      },
+      spring: {
+        r: 5,
+        g: 248,
+        b: 2
+      },
+      turquoise: {
+        r: 0,
+        g: 253,
+        b: 255
+      },
+      blueberry: {
+        r: 0,
+        g: 46,
+        b: 255
+      },
+      magenta: {
+        r: 255,
+        g: 57,
+        b: 255
+      },
+      iron: {
+        r: 84,
+        g: 84,
+        b: 83
+      },
+      magnesium: {
+        r: 184,
+        g: 184,
+        b: 184
+      },
+      mocha: {
+        r: 137,
+        g: 72,
+        b: 0
+      },
+      fern: {
+        r: 69,
+        g: 132,
+        b: 1
+      },
+      moss: {
+        r: 1,
+        g: 132,
+        b: 72
+      },
+      ocean: {
+        r: 0,
+        g: 74,
+        b: 136
+      },
+      eggplant: {
+        r: 73,
+        g: 26,
+        b: 136
+      },
+      maroon: {
+        r: 137,
+        g: 22,
+        b: 72
+      },
+      steel: {
+        r: 110,
+        g: 110,
+        b: 110
+      },
+      aluminum: {
+        r: 160,
+        g: 159,
+        b: 160
+      },
+      cayenne: {
+        r: 137,
+        g: 17,
+        b: 0
+      },
+      aspargus: {
+        r: 136,
+        g: 133,
+        b: 1
+      },
+      clover: {
+        r: 2,
+        g: 132,
+        b: 1
+      },
+      teal: {
+        r: 0,
+        g: 134,
+        b: 136
+      },
+      midnight: {
+        r: 0,
+        g: 24,
+        b: 136
+      },
+      plum: {
+        r: 137,
+        g: 30,
+        b: 136
+      },
+      tin: {
+        r: 135,
+        g: 134,
+        b: 135
+      },
+      nickel: {
+        r: 136,
+        g: 135,
+        b: 135
+      }
+    };
+
+    function appleCrayonRGB(name) {
+      const {
+        r,
+        g,
+        b
+      } = appleCrayonRGBPalette[name];
+      return `rgb(${r},${g},${b})`;
+    }
+
+    const colorPalettes = {
+      Set1: ["rgb(228,26,28)", "rgb(55,126,184)", "rgb(77,175,74)", "rgb(166,86,40)", "rgb(152,78,163)", "rgb(255,127,0)", "rgb(247,129,191)", "rgb(153,153,153)", "rgb(255,255,51)"],
+      Dark2: ["rgb(27,158,119)", "rgb(217,95,2)", "rgb(117,112,179)", "rgb(231,41,138)", "rgb(102,166,30)", "rgb(230,171,2)", "rgb(166,118,29)", "rgb(102,102,102)"],
+      Set2: ["rgb(102, 194,165)", "rgb(252,141,98)", "rgb(141,160,203)", "rgb(231,138,195)", "rgb(166,216,84)", "rgb(255,217,47)", "rgb(229,196,148)", "rgb(179,179,179)"],
+      Set3: ["rgb(141,211,199)", "rgb(255,255,179)", "rgb(190,186,218)", "rgb(251,128,114)", "rgb(128,177,211)", "rgb(253,180,98)", "rgb(179,222,105)", "rgb(252,205,229)", "rgb(217,217,217)", "rgb(188,128,189)", "rgb(204,235,197)", "rgb(255,237,111)"],
+      Pastel1: ["rgb(251,180,174)", "rgb(179,205,227)", "rgb(204,235,197)", "rgb(222,203,228)", "rgb(254,217,166)", "rgb(255,255,204)", "rgb(229,216,189)", "rgb(253,218,236)"],
+      Pastel2: ["rgb(173,226,207)", "rgb(253,205,172)", "rgb(203,213,232)", "rgb(244,202,228)", "rgb(230,245,201)", "rgb(255,242,174)", "rgb(243,225,206)"],
+      Accent: ["rgb(127,201,127)", "rgb(190,174,212)", "rgb(253,192,134)", "rgb(255,255,153)", "rgb(56,108,176)", "rgb(240,2,127)", "rgb(191,91,23)"]
+    };
+
+    class PaletteColorTable {
+      constructor(palette) {
+        this.colors = colorPalettes[palette];
+        if (!Array.isArray(this.colors)) this.colors = [];
+        this.colorTable = {};
+        this.nextIdx = 0;
+        this.colorGenerator = new RandomColorGenerator();
+      }
+
+      getColor(key) {
+        if (!this.colorTable.hasOwnProperty(key)) {
+          if (this.nextIdx < this.colors.length) {
+            this.colorTable[key] = this.colors[this.nextIdx];
+          } else {
+            this.colorTable[key] = this.colorGenerator.get();
+          }
+
+          this.nextIdx++;
+        }
+
+        return this.colorTable[key];
+      }
+
+    }
+
+    class ColorTable {
+      constructor(colors) {
+        this.colorTable = colors || {};
+        this.nextIdx = 0;
+        this.colorGenerator = new RandomColorGenerator();
+      }
+
+      getColor(key) {
+        if (!this.colorTable.hasOwnProperty(key)) {
+          if (this.colorTable.hasOwnProperty("*")) {
+            return this.colorTable["*"];
+          }
+
+          this.colorTable[key] = this.colorGenerator.get();
+        }
+
+        return this.colorTable[key];
+      }
+
+    } // Random color generator from https://github.com/sterlingwes/RandomColor/blob/master/rcolor.js
+    // Free to use & distribute under the MIT license
+    // Wes Johnson (@SterlingWes)
+    //
+    // inspired by http://martin.ankerl.com/2009/12/09/how-to-create-random-colors-programmatically/
+
+
+    function RandomColorGenerator() {
+      this.hue = Math.random();
+      this.goldenRatio = 0.618033988749895;
+      this.hexwidth = 2;
+    }
+
+    RandomColorGenerator.prototype.hsvToRgb = function (h, s, v) {
+      var h_i = Math.floor(h * 6),
+          f = h * 6 - h_i,
+          p = v * (1 - s),
+          q = v * (1 - f * s),
+          t = v * (1 - (1 - f) * s),
+          r = 255,
+          g = 255,
+          b = 255;
+
+      switch (h_i) {
+        case 0:
+          r = v, g = t, b = p;
+          break;
+
+        case 1:
+          r = q, g = v, b = p;
+          break;
+
+        case 2:
+          r = p, g = v, b = t;
+          break;
+
+        case 3:
+          r = p, g = q, b = v;
+          break;
+
+        case 4:
+          r = t, g = p, b = v;
+          break;
+
+        case 5:
+          r = v, g = p, b = q;
+          break;
+      }
+
+      return [Math.floor(r * 256), Math.floor(g * 256), Math.floor(b * 256)];
+    };
+
+    RandomColorGenerator.prototype.padHex = function (str) {
+      if (str.length > this.hexwidth) return str;
+      return new Array(this.hexwidth - str.length + 1).join('0') + str;
+    };
+
+    RandomColorGenerator.prototype.get = function (saturation, value) {
+      this.hue += this.goldenRatio;
+      this.hue %= 1;
+      if (typeof saturation !== "number") saturation = 0.5;
+      if (typeof value !== "number") value = 0.95;
+      var rgb = this.hsvToRgb(this.hue, saturation, value);
+      return "#" + this.padHex(rgb[0].toString(16)) + this.padHex(rgb[1].toString(16)) + this.padHex(rgb[2].toString(16));
+    };
+
+    const randomColorGenerator = new RandomColorGenerator();
+
+    function randomColor() {
+      return randomColorGenerator.get();
+    } // Returns a random number between min (inclusive) and max (exclusive)
+
+    const maxFontSize = 10;
+    const fontConfigureTemplate = {
+      // font: '2pt sans-serif',
+      textAlign: 'start',
+      textBaseline: 'bottom',
+      strokeStyle: 'black',
+      fillStyle: 'black'
+    };
+
+    class SampleNameViewport {
+      constructor(trackView, $viewportContainer, referenceFrame, width) {
+        this.guid = guid();
+        this.trackView = trackView;
+        this.referenceFrame = referenceFrame;
+        this.browser = trackView.browser;
+        this.$viewport = $('<div class="igv-viewport">');
+        $viewportContainer.append(this.$viewport);
+        this.$canvas = $('<canvas class ="igv-canvas">');
+        this.$viewport.append(this.$canvas);
+        this.canvas = this.$canvas.get(0);
+        this.ctx = this.canvas.getContext("2d");
+        this.contentTop = 0;
+        this.setWidth(width);
+        this.$viewport.get(0).addEventListener('contextmenu', e => {
+          e.preventDefault();
+          e.stopPropagation();
+          const config = {
+            label: 'Name Panel Width',
+            value: this.browser.sampleNameViewportWidth,
+            callback: width => {
+              this.browser.sampleNameViewportWidth = width;
+
+              for (let {
+                sampleNameViewport
+              } of this.browser.trackViews) {
+                sampleNameViewport.setWidth(this.browser.sampleNameViewportWidth);
+              }
+
+              this.browser.resize();
+            }
+          };
+          this.browser.inputDialog.present(config, e);
+        });
+      }
+
+      checkCanvas() {
+        const dpi = window.devicePixelRatio;
+        const requiredHeight = this.$viewport.height();
+        const requiredWidth = this.browser.sampleNameViewportWidth;
+
+        if (this.canvas.width !== requiredWidth * dpi || this.canvas.height !== requiredHeight * dpi) {
+          const canvas = this.canvas;
+          canvas.width = requiredWidth * dpi;
+          canvas.height = requiredHeight * dpi;
+          canvas.style.width = `${requiredWidth}px`;
+          canvas.style.height = `${requiredHeight}px`;
+          this.ctx = this.canvas.getContext("2d");
+          this.ctx.scale(dpi, dpi);
+        }
+      }
+
+      setTop(contentTop) {
+        if (typeof this.trackView.track.getSamples === 'function') {
+          this.contentTop = contentTop;
+          const samples = this.trackView.track.getSamples();
+          this.repaint(samples);
+        }
+      }
+
+      setWidth(width) {
+        this.$viewport.width(width);
+        this.checkCanvas();
+      }
+
+      show() {
+        this.$viewport.show();
+      }
+
+      hide() {
+        this.$viewport.hide();
+      }
+
+      async repaint(samples) {
+        this.checkCanvas();
+        this.draw({
+          context: this.ctx,
+          samples
+        });
+      }
+
+      draw({
+        context,
+        samples
+      }) {
+        if (!samples || samples.names.length === 0 || samples.height < 1) {
+          return;
+        }
+
+        configureFont(context, fontConfigureTemplate, samples.height);
+        const sampleNameXShim = 4;
+        context.clearRect(0, 0, context.canvas.width, context.canvas.height);
+        context.fillStyle = appleCrayonRGB('lead');
+        const viewportHeight = this.$viewport.get(0).getBoundingClientRect().height;
+        let y = (samples.yOffset || 0) + this.contentTop; // contentTop will always be a negative number (top relative to viewport)
+
+        for (let name of samples.names) {
+          if (y > viewportHeight) break;
+
+          if (y + samples.height > 0) {
+            const text = name.toUpperCase();
+            const yFont = getYFont(context, text, y, samples.height);
+            context.fillText(text, sampleNameXShim, yFont);
+          }
+
+          y += samples.height;
+        }
+      }
+
+      renderSVGContext(context, {
+        deltaX,
+        deltaY
+      }) {
+        if (typeof this.trackView.track.getSamples === 'function') {
+          const samples = this.trackView.track.getSamples();
+          const yScrollDelta = 0; // This is not relevant, scrolling is handled in "draw"
+
+          const {
+            width,
+            height
+          } = this.$viewport.get(0).getBoundingClientRect();
+          const str = (this.trackView.track.name || this.trackView.track.id).replace(/\W/g, '');
+          const id = `${str}_sample_names_guid_${guid()}`;
+          context.saveWithTranslationAndClipRect(id, deltaX, deltaY + yScrollDelta, width, height, -yScrollDelta);
+          this.draw({
+            context,
+            samples
+          });
+          context.restore();
+        }
+      }
+
+      addMouseHandler(context, pixelTop, samples) {
+        this.canvas.addEventListener('click', e => {
+          if ('block' === this.hover.style.display) {
+            this.hover.style.display = 'none';
+            this.hover.textContent = '';
+          } else {
+            const {
+              currentTarget,
+              clientY
+            } = e;
+            const {
+              y: target_bbox_min_y
+            } = currentTarget.getBoundingClientRect();
+            const y = clientY - target_bbox_min_y + pixelTop;
+            let yMin = 0;
+
+            for (let name of samples.names) {
+              const yMax = getYFont(context, name.toUpperCase(), yMin, samples.height);
+
+              if (y < yMin || y > yMax) ; else {
+                this.hover.style.top = `${yMin + this.contentTop}px`;
+                this.hover.style.right = '0px';
+                this.hover.textContent = name.toUpperCase();
+                this.hover.style.display = 'block';
+              }
+
+              yMin += samples.height;
+            }
+          }
+        });
+        this.canvas.addEventListener('mouseleave', () => {
+          this.hover.style.display = 'none';
+          this.hover.textContent = '';
+        });
+      }
+
+    }
+
+    function getYFont(context, text, y, height) {
+      return y + height - getSampleNameYShim(context, text, height);
+    }
+
+    function getSampleNameYShim(context, text, h) {
+      const {
+        fontBoundingBoxAscent,
+        fontBoundingBoxDescent
+      } = context.measureText(text);
+      return (h - (fontBoundingBoxAscent + fontBoundingBoxDescent)) / 2;
+    }
+
+    function configureFont(ctx, {
+      textAlign,
+      textBaseline,
+      strokeStyle,
+      fillStyle
+    }, sampleHeight) {
+      const pixels = Math.min(sampleHeight, maxFontSize);
+      ctx.font = `${pixels}px sans-serif`;
+      ctx.textAlign = textAlign;
+      ctx.textBaseline = textBaseline;
+      ctx.fillStyle = fillStyle;
+    }
+
+    const namespace = '.trackscrollbar' + guid();
+
+    class TrackScrollbar {
+      constructor($viewportContainer, viewports, sampleNameViewport) {
+        let lastY; // Define mouse events first, use arrow function so "this" is in scope
+
+        const mouseMove = event => {
+          event.preventDefault();
+          event.stopPropagation();
+          const page = pageCoordinates$1(event);
+          this.moveScrollerBy(page.y - lastY);
+          lastY = page.y;
+        };
+
+        const mouseUp = event => {
+          $(document).off(this.namespace);
+        };
+
+        const mouseDown = event => {
+          event.preventDefault();
+          const page = pageCoordinates$1(event);
+          lastY = page.y;
+          $(document).on('mousemove' + namespace, mouseMove);
+          $(document).on('mouseup' + namespace, mouseUp);
+          $(document).on('mouseleave' + namespace, mouseUp); // prevents start of horizontal track panning)
+
+          event.stopPropagation();
+        };
+
+        this.namespace = namespace;
+        this.$outerScroll = $('<div class="igv-scrollbar-outer-div">');
+        this.$innerScroll = $('<div>');
+        this.$outerScroll.append(this.$innerScroll);
+        this.$viewportContainer = $viewportContainer;
+        this.viewports = viewports;
+        this.sampleNameViewport = sampleNameViewport;
+        this.$innerScroll.on("mousedown", mouseDown);
+        this.$innerScroll.on("click", event => {
+          event.stopPropagation();
+        });
+        this.$outerScroll.on("click", event => {
+          this.moveScrollerBy(event.offsetY - this.$innerScroll.height() / 2);
+          event.stopPropagation();
+        });
+      }
+
+      disableMouseHandlers() {
+        $(document).off(namespace);
+        this.$innerScroll.off();
+        this.$outerScroll.off();
+      }
+
+      moveScrollerBy(delta) {
+        const y = this.$innerScroll.position().top + delta;
+        this.moveScrollerTo(y);
+      }
+
+      moveScrollerTo(y) {
+        const outerScrollHeight = this.$outerScroll.height();
+        const innerScrollHeight = this.$innerScroll.height();
+        const newTop = Math.min(Math.max(0, y), outerScrollHeight - innerScrollHeight);
+        const contentDivHeight = maxViewportContentHeight(this.viewports);
+        const contentTop = -Math.round(newTop * (contentDivHeight / this.$viewportContainer.height()));
+        this.$innerScroll.css("top", newTop + "px");
+
+        for (let viewport of [...this.viewports, this.sampleNameViewport]) {
+          viewport.setTop(contentTop);
+        }
+      }
+
+      dispose() {
+        $(window).off(this.namespace);
+        this.$innerScroll.off();
+      }
+
+      update() {
+        const viewportContainerHeight = this.$viewportContainer.height();
+        const viewportContentHeight = maxViewportContentHeight(this.viewports);
+        const innerScrollHeight = Math.round(viewportContainerHeight / viewportContentHeight * viewportContainerHeight);
+
+        if (viewportContentHeight > viewportContainerHeight) {
+          this.$innerScroll.show();
+          this.$innerScroll.height(innerScrollHeight);
+        } else {
+          this.$innerScroll.hide();
+        }
+      }
+
+    }
+
+    /*
+     * The MIT License (MIT)
+     *
+     * Copyright (c) 2014 Broad Institute
+     *
+     * Permission is hereby granted, free of charge, to any person obtaining a copy
+     * of this software and associated documentation files (the "Software"), to deal
+     * in the Software without restriction, including without limitation the rights
+     * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+     * copies of the Software, and to permit persons to whom the Software is
+     * furnished to do so, subject to the following conditions:
+     *
+     * The above copyright notice and this permission notice shall be included in
+     * all copies or substantial portions of the Software.
+     *
+     *
+     * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+     * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+     * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+     * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+     * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+     * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+     * THE SOFTWARE.
+     */
+    const defaultSequenceTrackOrder = Number.MIN_SAFE_INTEGER;
+    const translationDict = {
+      'TTT': 'F',
+      'TTC': 'F',
+      'TTA': 'L',
+      'TTG': 'L',
+      'CTT': 'L',
+      'CTC': 'L',
+      'CTA': 'L',
+      'CTG': 'L',
+      'ATT': 'I',
+      'ATC': 'I',
+      'ATA': 'I',
+      'ATG': 'M',
+      'GTT': 'V',
+      'GTC': 'V',
+      'GTA': 'V',
+      'GTG': 'V',
+      'TCT': 'S',
+      'TCC': 'S',
+      'TCA': 'S',
+      'TCG': 'S',
+      'CCT': 'P',
+      'CCC': 'P',
+      'CCA': 'P',
+      'CCG': 'P',
+      'ACT': 'T',
+      'ACC': 'T',
+      'ACA': 'T',
+      'ACG': 'T',
+      'GCT': 'A',
+      'GCC': 'A',
+      'GCA': 'A',
+      'GCG': 'A',
+      'TAT': 'Y',
+      'TAC': 'Y',
+      'TAA': 'STOP',
+      'TAG': 'STOP',
+      'CAT': 'H',
+      'CAC': 'H',
+      'CAA': 'Q',
+      'CAG': 'Q',
+      'AAT': 'N',
+      'AAC': 'N',
+      'AAA': 'K',
+      'AAG': 'K',
+      'GAT': 'D',
+      'GAC': 'D',
+      'GAA': 'E',
+      'GAG': 'E',
+      'TGT': 'C',
+      'TGC': 'C',
+      'TGA': 'STOP',
+      'TGG': 'W',
+      'CGT': 'R',
+      'CGC': 'R',
+      'CGA': 'R',
+      'CGG': 'R',
+      'AGT': 'S',
+      'AGC': 'S',
+      'AGA': 'R',
+      'AGG': 'R',
+      'GGT': 'G',
+      'GGC': 'G',
+      'GGA': 'G',
+      'GGG': 'G'
+    };
+    const complement = {};
+    const t1 = ['A', 'G', 'C', 'T', 'Y', 'R', 'W', 'S', 'K', 'M', 'D', 'V', 'H', 'B', 'N', 'X'];
+    const t2 = ['T', 'C', 'G', 'A', 'R', 'Y', 'W', 'S', 'M', 'K', 'H', 'B', 'D', 'V', 'N', 'X'];
+
+    for (let i = 0; i < t1.length; i++) {
+      complement[t1[i]] = t2[i];
+      complement[t1[i].toLowerCase()] = t2[i].toLowerCase();
+    }
+
+    class SequenceTrack {
+      constructor(config, browser) {
+        this.type = "sequence";
+        this.browser = browser;
+        this.removable = false;
+        this.config = config;
+        this.name = "Sequence";
+        this.id = "sequence";
+        this.sequenceType = config.sequenceType || "dna"; //   dna | rna | prot
+
+        this.height = 25;
+        this.disableButtons = false;
+        this.order = config.order || defaultSequenceTrackOrder;
+        this.ignoreTrackMenu = false;
+        this.reversed = false;
+        this.frameTranslate = false;
+      }
+
+      menuItemList() {
+        return [{
+          name: this.reversed ? "Forward" : "Reverse",
+          click: () => {
+            this.reversed = !this.reversed;
+            this.trackView.repaintViews();
+          }
+        }, {
+          name: this.frameTranslate ? "Close Translation" : "Three-frame Translate",
+          click: () => {
+            this.frameTranslate = !this.frameTranslate;
+
+            if (this.frameTranslate) {
+              for (let vp of this.trackView.viewports) {
+                vp.setContentHeight(115);
+              }
+
+              this.trackView.setTrackHeight(115);
+            } else {
+              for (let vp of this.trackView.viewports) {
+                vp.setContentHeight(25);
+              }
+
+              this.trackView.setTrackHeight(25);
+            }
+
+            this.trackView.repaintViews();
+          }
+        }];
+      }
+
+      contextMenuItemList(clickState) {
+        const viewport = clickState.viewport;
+
+        if (viewport.referenceFrame.bpPerPixel <= 1) {
+          return [{
+            label: 'Copy visible sequence...',
+            click: async () => {
+              const pixelWidth = viewport.getWidth();
+              const bpWindow = pixelWidth * viewport.referenceFrame.bpPerPixel;
+              const chr = viewport.referenceFrame.chr;
+              const start = viewport.referenceFrame.start;
+              const end = start + bpWindow;
+              const sequence = await this.browser.genome.sequence.getSequence(chr, start, end);
+
+              if (viewport.trackView.alert) {
+                viewport.trackView.alert.present(sequence);
+              } else {
+                Alert.presentAlert(sequence);
+              }
+            }
+          }, '<hr/>'];
+        } else {
+          return undefined;
+        }
+      }
+
+      translateSequence(seq) {
+        const threeFrame = [[], [], []];
+
+        for (let fNum of [0, 1, 2]) {
+          let idx = fNum;
+
+          while (seq.length - idx >= 3) {
+            let st = seq.slice(idx, idx + 3);
+
+            if (this.reversed) {
+              st = st.split('').reverse().join('');
+            }
+
+            const aa = translationDict[st.toUpperCase()] || "";
+            threeFrame[fNum].push({
+              codons: st,
+              aminoA: aa
+            });
+            idx += 3;
+          }
+        }
+
+        return threeFrame;
+      }
+
+      async getFeatures(chr, start, end, bpPerPixel) {
+        if (bpPerPixel && bpPerPixel > 1) {
+          return null;
+        } else {
+          const sequence = await this.browser.genome.sequence.getSequence(chr, start, end);
+          return {
+            bpStart: start,
+            sequence: sequence
+          };
+        }
+      }
+
+      draw(options) {
+        const ctx = options.context;
+
+        if (options.features) {
+          const sequence = options.features.sequence;
+          const sequenceBpStart = options.features.bpStart;
+          const bpEnd = 1 + options.bpStart + options.pixelWidth * options.bpPerPixel;
+          let height = 15;
+
+          for (let bp = sequenceBpStart; bp <= bpEnd; bp++) {
+            let seqOffsetBp = Math.floor(bp - sequenceBpStart);
+
+            if (seqOffsetBp < sequence.length) {
+              let letter = sequence[seqOffsetBp];
+
+              if (this.reversed) {
+                letter = complement[letter] || "";
+              }
+
+              let offsetBP = bp - options.bpStart;
+              let aPixel = offsetBP / options.bpPerPixel;
+              let bPixel = (offsetBP + 1) / options.bpPerPixel;
+              let color = this.fillColor(letter);
+
+              if (options.bpPerPixel > 1 / 10) {
+                IGVGraphics.fillRect(ctx, aPixel, 5, bPixel - aPixel, height - 5, {
+                  fillStyle: color
+                });
+              } else {
+                let xPixel = 0.5 * (aPixel + bPixel - ctx.measureText(letter).width);
+                IGVGraphics.strokeText(ctx, letter, xPixel, height, {
+                  strokeStyle: color
+                });
+              }
+            }
+          }
+
+          if (this.frameTranslate) {
+            let transSeq;
+
+            if (this.reversed) {
+              transSeq = sequence.split('').map(function (cv) {
+                return complement[cv];
+              });
+              transSeq = transSeq.join('');
+            } else {
+              transSeq = sequence;
+            }
+
+            let y = height;
+            let translatedSequence = this.translateSequence(transSeq);
+
+            for (let arr of translatedSequence) {
+              let i = translatedSequence.indexOf(arr);
+              let fNum = i;
+              let h = 25;
+              y = i === 0 ? y + 10 : y + 30; //Little less room at first.
+
+              for (let cv of arr) {
+                let aaS;
+                let idx = arr.indexOf(cv);
+                let xSeed = idx + fNum + 2 * idx;
+                let color = 0 === idx % 2 ? 'rgb(160,160,160)' : 'rgb(224,224,224)';
+                let p0 = Math.floor(xSeed / options.bpPerPixel);
+                let p1 = Math.floor((xSeed + 3) / options.bpPerPixel);
+                let pc = Math.round((p0 + p1) / 2);
+
+                if (cv.aminoA.indexOf('STOP') > -1) {
+                  color = 'rgb(255, 0, 0)';
+                  aaS = 'STOP'; //Color blind accessible
+                } else {
+                  aaS = cv.aminoA;
+                }
+
+                if (cv.aminoA === 'M') {
+                  color = 'rgb(0, 153, 0)';
+                  aaS = 'START'; //Color blind accessible
+                }
+
+                IGVGraphics.fillRect(ctx, p0, y, p1 - p0, h, {
+                  fillStyle: color
+                });
+
+                if (options.bpPerPixel <= 1 / 10) {
+                  IGVGraphics.strokeText(ctx, aaS, pc - ctx.measureText(aaS).width / 2, y + 15);
+                }
+              }
+            }
+          }
+        }
+      }
+
+      supportsWholeGenome() {
+        return false;
+      }
+
+      computePixelHeight(ignore) {
+        return this.height;
+      }
+
+      fillColor(index) {
+        if (this.color) {
+          return this.color;
+        } else if ("dna" === this.sequenceType) {
+          return this.browser.nucleotideColors[index] || 'gray';
+        } else {
+          return 'rgb(0, 0, 150)';
+        }
+      }
+
+    }
+
+    /*
+     * The MIT License (MIT)
+     *
+     * Copyright (c) 2014 Broad Institute
+     *
+     * Permission is hereby granted, free of charge, to any person obtaining a copy
+     * of this software and associated documentation files (the "Software"), to deal
+     * in the Software without restriction, including without limitation the rights
+     * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+     * copies of the Software, and to permit persons to whom the Software is
+     * furnished to do so, subject to the following conditions:
+     *
+     * The above copyright notice and this permission notice shall be included in
+     * all copies or substantial portions of the Software.
+     *
+     *
+     * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+     * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+     * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+     * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+     * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+     * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+     * THE SOFTWARE.
+     */
+    const axisContainerWidth = 50;
+
+    class TrackView {
+      constructor(browser, $container, track) {
+        this.browser = browser;
+        this.track = track;
+        track.trackView = this;
+        const $track = $('<div class="igv-track">');
+        this.trackDiv = $track.get(0);
+        $container.append($track);
+        this.namespace = '.trackview_' + guid();
+
+        if (track instanceof RulerTrack) {
+          this.trackDiv.dataset.rulerTrack = "rulerTrack";
+        } // Create an alert dialog for the sequence track to copy ref sequence to.  Obviously a little hacky.
+
+
+        if (track instanceof SequenceTrack) {
+          this.alert = new AlertDialog(this.trackDiv);
+        }
+
+        if (track.height) {
+          this.trackDiv.style.height = track.height + "px";
+        }
+
+        this.$viewportContainer = $('<div class="igv-viewport-container">');
+        $track.append(this.$viewportContainer); // add axis to viewportContainer
+
+        this.$axis = this.createAxis(this.$viewportContainer); // add viewport(s) to viewportContainer. One viewport per reference frame
+
+        this.populateViewportContainer(browser, browser.referenceFrameList); // Track drag handle
+
+        if ('ideogram' === track.type || 'ruler' === track.type) ; else {
+          this.attachDragWidget($track, this.$viewportContainer);
+        } // right hand gutter
+
+
+        if (true === track.ignoreTrackMenu) ; else {
+          this.appendRightHandGutter($track);
+        } // color picker
+
+
+        const trackColors = [];
+        const color = track.color || track.defaultColor;
+
+        if (isString$6(color)) {
+          trackColors.push(color);
+        }
+
+        if (track.altColor && isString$6(track.altColor)) {
+          trackColors.push(track.altColor);
+        }
+
+        const defaultColors = trackColors.map(c => {
+          return c.startsWith("#") ? c : c.startsWith("rgb(") ? IGVColor.rgbToHex(c) : IGVColor.colorNameToHex(c);
+        });
+        const options = {
+          parent: this.trackDiv,
+          top: undefined,
+          left: undefined,
+          width: 432,
+          height: undefined,
+          defaultColors,
+          colorHandler: color => {
+            this.track.color = color;
+            this.repaintViews();
+          }
+        };
+        this.colorPicker = new ColorPicker(options); // alt color picker -- TODO pass handler in at "show" time and use 1 color picker
+
+        options.colorHandler = color => {
+          this.track.altColor = color;
+          this.repaintViews();
+        };
+
+        this.altColorPicker = new ColorPicker(options);
+      }
+
+      populateViewportContainer(browser, referenceFrameList) {
+        const width = browser.computeViewportWidth(referenceFrameList.length, browser.getViewportContainerWidth());
+        this.viewports = [];
+
+        for (let referenceFrame of referenceFrameList) {
+          const viewport = createViewport(this, referenceFrameList, referenceFrameList.indexOf(referenceFrame), width);
+          this.viewports.push(viewport);
+        }
+
+        this.sampleNameViewport = new SampleNameViewport(this, this.$viewportContainer, undefined, browser.sampleNameViewportWidth);
+
+        if (false === browser.showSampleNames) {
+          this.sampleNameViewport.$viewport.hide();
+        } else {
+          this.sampleNameViewport.$viewport.show();
+        }
+
+        updateViewportShims(this.viewports, this.$viewportContainer);
+        this.updateViewportForMultiLocus();
+        this.attachScrollbar($(this.trackDiv), this.$viewportContainer, this.viewports, this.sampleNameViewport);
+      }
+
+      renderSVGContext(context, {
+        deltaX,
+        deltaY
+      }) {
+        renderSVGAxis(context, this.track, this.axisCanvas, deltaX, deltaY);
+        const {
+          width: axisWidth
+        } = this.$axis.get(0).getBoundingClientRect();
+        const {
+          y
+        } = this.viewports[0].$viewport.get(0).getBoundingClientRect();
+        let delta = {
+          deltaX: axisWidth + deltaX,
+          deltaY: y + deltaY
+        };
+
+        for (let viewport of this.viewports) {
+          viewport.renderSVGContext(context, delta);
+          const {
+            width
+          } = viewport.$viewport.get(0).getBoundingClientRect();
+          delta.deltaX += width;
+        }
+
+        if (true === this.browser.showSampleNames) {
+          this.sampleNameViewport.renderSVGContext(context, delta);
+        }
+      }
+
+      attachScrollbar($track, $viewportContainer, viewports, sampleNameViewport) {
+        if ("hidden" === $viewportContainer.find('.igv-viewport').css("overflow-y")) {
+          this.scrollbar = new TrackScrollbar($viewportContainer, viewports, sampleNameViewport);
+          this.scrollbar.$outerScroll.insertAfter($viewportContainer);
+
+          if ('ruler' === this.track.type || 'ideogram' === this.track.type) {
+            this.scrollbar.disableMouseHandlers();
+          }
+        }
+      }
+
+      removeViewportForReferenceFrame(referenceFrame) {
+        let index = -1;
+
+        for (let i = 0; i < this.viewports.length; i++) {
+          if (this.viewports[i].referenceFrame === referenceFrame) {
+            index = i;
+            break;
+          }
+        }
+
+        if (index >= 0) {
+          this.viewports[index].$viewport.remove();
+          this.viewports.splice(index, 1);
+          this.updateViewportForMultiLocus();
+        }
+      }
+
+      updateViewportForMultiLocus() {
+        if ('ruler' === this.track.type) {
+          if (this.viewports.length > 1) {
+            this.$viewportContainer.find('.igv-multi-locus-panel-close-container').show();
+            this.$viewportContainer.find('.igv-multi-locus-panel-label-div').show();
+            this.track.updateLocusLabel();
+          } else {
+            this.$viewportContainer.find('.igv-multi-locus-panel-close-container').hide();
+            this.$viewportContainer.find('.igv-multi-locus-panel-label-div').hide();
+          }
+        }
+      }
+
+      createAxis($viewportContainer) {
+        const $axis = $('<div class="igv-axis-container">');
+        $viewportContainer.append($axis);
+
+        if (typeof this.track.paintAxis === 'function') {
+          if (this.track.dataRange) {
+            $axis.click(() => {
+              this.browser.dataRangeDialog.configure(this);
+              this.browser.dataRangeDialog.present($(this.trackDiv));
+            });
+            $axis.addClass('igv-clickable');
+          }
+
+          this.resizeAxisCanvas($axis, $axis.outerWidth(), $axis.outerHeight());
+        }
+
+        return $axis;
+      }
+
+      dataRange() {
+        return this.track.dataRange ? this.track.dataRange : undefined;
+      }
+
+      setDataRange(min, max) {
+        if (min !== undefined) {
+          this.track.dataRange.min = min;
+        }
+
+        if (max !== undefined) {
+          this.track.dataRange.max = max;
+        }
+
+        this.track.autoscale = false;
+        this.repaintViews();
+      }
+
+      presentColorPicker(option) {
+        if (option === "altColor") {
+          this.altColorPicker.show();
+        } else {
+          this.colorPicker.show();
+        }
+      }
+
+      setTrackHeight(newHeight, force) {
+        if (!force) {
+          if (this.track.minHeight) {
+            newHeight = Math.max(this.track.minHeight, newHeight);
+          }
+
+          if (this.track.maxHeight) {
+            newHeight = Math.min(this.track.maxHeight, newHeight);
+          }
+        }
+
+        this.track.height = newHeight;
+        this.track.config.height = newHeight;
+        $(this.trackDiv).height(newHeight); // If the track does not manage its own content height set it here
+
+        if (typeof this.track.computePixelHeight !== "function") {
+          for (let vp of this.viewports) {
+            vp.setContentHeight(newHeight);
+          }
+        }
+
+        this.repaintViews();
+        this.resizeAxisCanvas(this.$axis, this.$axis.outerWidth(), newHeight);
+
+        if (this.track.paintAxis) {
+          this.track.paintAxis(this.axisCanvasContext, this.axisCanvasContext.canvas.width, this.axisCanvasContext.canvas.height);
+        }
+
+        if (this.scrollbar) {
+          this.scrollbar.update();
+        }
+      }
+
+      isLoading() {
+        for (let i = 0; i < this.viewports.length; i++) {
+          if (this.viewports[i].isLoading()) return true;
+        }
+      }
+
+      resize(viewportWidth) {
+        for (let viewport of this.viewports) {
+          viewport.setWidth(viewportWidth);
+        }
+
+        this.resizeAxisCanvas(this.$axis, this.$axis.outerWidth(), this.$axis.outerHeight());
+        this.updateViews(true);
+      }
+      /**
+       * Repaint all viewports without loading any new data.   Use this for events that change visual aspect of data,
+       * e.g. color, sort order, etc, but do not change the genomic state.
+       */
+
+
+      repaintViews() {
+        for (let viewport of this.viewports) {
+          viewport.repaint();
+        }
+
+        if (this.track.paintAxis) {
+          this.track.paintAxis(this.axisCanvasContext, this.axisCanvasContext.canvas.width, this.axisCanvasContext.canvas.height);
+        } // Repaint sample names last
+
+
+        this.repaintSamples();
+      }
+
+      repaintSamples() {
+        if (typeof this.track.getSamples === 'function') {
+          const samples = this.track.getSamples();
+          this.sampleNameViewport.repaint(samples);
+        }
+      }
+      /**
+       * Update viewports to reflect current genomic state, possibly loading additional data.
+       */
+
+
+      async updateViews(force) {
+        if (!(this.browser && this.browser.referenceFrameList)) return;
+        const visibleViewports = this.viewports.filter(vp => vp.isVisible()); // Shift viewports left/right to current genomic state (pans canvas)
+
+        visibleViewports.forEach(function (viewport) {
+          viewport.shift();
+        }); // rpv: viewports whose image (canvas) does not fully cover current genomic range
+
+        const rpV = this.viewportsToReload(force); // Trigger viewport to load features needed to cover current genomic range
+
+        for (let vp of rpV) {
+          await vp.loadFeatures();
+        } // Very special case for variant tracks in multilocus view.  The # of rows to allocate to the variant (site)
+        // section depends on data from all the views.
+
+
+        if (typeof this.track.variantRowCount === 'function') {
+          let maxRow = 0;
+
+          for (let vp of this.viewports) {
+            if (vp.tile && vp.tile.features) {
+              maxRow = Math.max(maxRow, vp.tile.features.reduce((a, f) => Math.max(a, f.row || 0), 0));
+            }
+          }
+
+          const current = this.track.nVariantRows;
+
+          if (current !== maxRow + 1) {
+            this.track.variantRowCount(maxRow + 1);
+
+            for (let vp of this.viewports) {
+              vp.checkContentHeight();
+            }
+          }
+        }
+
+        if (this.disposed) return; // Track was removed during load
+
+        const isDragging = this.browser.dragObject;
+
+        if (!isDragging && this.track.autoscale) {
+          let allFeatures = [];
+
+          for (let vp of visibleViewports) {
+            const referenceFrame = vp.referenceFrame;
+            const start = referenceFrame.start;
+            const end = start + referenceFrame.toBP($(vp.contentDiv).width());
+
+            if (vp.tile && vp.tile.features) {
+              if (typeof vp.tile.features.getMax === 'function') {
+                const max = vp.tile.features.getMax(start, end);
+                allFeatures.push({
+                  value: max
+                });
+              } else {
+                allFeatures = allFeatures.concat(FeatureUtils.findOverlapping(vp.tile.features, start, end));
+              }
+            }
+          }
+
+          if (typeof this.track.doAutoscale === 'function') {
+            this.track.dataRange = this.track.doAutoscale(allFeatures);
+          } else {
+            this.track.dataRange = doAutoscale(allFeatures);
+          }
+        } // Must repaint all viewports if autoscaling
+
+
+        if (!isDragging && (this.track.autoscale || this.track.autoscaleGroup)) {
+          for (let vp of visibleViewports) {
+            vp.repaint();
+          }
+        } else {
+          for (let vp of rpV) {
+            vp.repaint();
+          }
+        }
+
+        this.adjustTrackHeight(); // Repaint sample names last
+
+        this.repaintSamples();
+      }
+      /**
+       * Return a promise to get all in-view features.  Used for group autoscaling.
+       */
+
+
+      async getInViewFeatures(force) {
+        if (!(this.browser && this.browser.referenceFrameList)) {
+          return [];
+        } // List of viewports that need reloading
+
+
+        const rpV = this.viewportsToReload(force);
+        const promises = rpV.map(function (vp) {
+          return vp.loadFeatures();
+        });
+        await Promise.all(promises);
+        let allFeatures = [];
+
+        for (let vp of this.viewports) {
+          if (vp.tile && vp.tile.features) {
+            const referenceFrame = vp.referenceFrame;
+            const start = referenceFrame.start;
+            const end = start + referenceFrame.toBP($(vp.contentDiv).width());
+
+            if (typeof vp.tile.features.getMax === 'function') {
+              const max = vp.tile.features.getMax(start, end);
+              allFeatures.push({
+                value: max
+              });
+            } else {
+              allFeatures = allFeatures.concat(FeatureUtils.findOverlapping(vp.tile.features, start, end));
+            }
+          }
+        }
+
+        return allFeatures;
+      }
+
+      checkContentHeight() {
+        for (let viewport of this.viewports) {
+          viewport.checkContentHeight();
+        }
+
+        this.adjustTrackHeight();
+      }
+
+      adjustTrackHeight() {
+        var maxHeight = maxViewportContentHeight(this.viewports);
+
+        if (this.track.autoHeight) {
+          this.setTrackHeight(maxHeight, false);
+        } else if (this.track.paintAxis) {
+          // Avoid duplication, paintAxis is already called in setTrackHeight
+          this.track.paintAxis(this.axisCanvasContext, this.axisCanvasContext.canvas.width, this.axisCanvasContext.canvas.height);
+        }
+
+        if (this.scrollbar) {
+          const currentTop = this.viewports[0].getContentTop();
+          const viewports = [...this.viewports, this.sampleNameViewport];
+          const heights = this.viewports.map(viewport => viewport.getContentHeight());
+          const minContentHeight = Math.min(...heights);
+          const newTop = Math.min(0, this.$viewportContainer.height() - minContentHeight);
+
+          if (currentTop < newTop) {
+            for (let viewport of viewports) {
+              viewport.$content.css("top", `${newTop}px`);
+            }
+          }
+
+          this.scrollbar.update();
+        }
+      }
+
+      resizeAxisCanvas($axis, width, height) {
+        if ($axis) {
+          if (this.axisCanvas) {
+            $(this.axisCanvas).remove();
+          }
+
+          const $canvas = $('<canvas class ="igv-canvas">');
+          $axis.append($canvas);
+          this.axisCanvas = $canvas.get(0);
+          this.axisCanvasContext = this.axisCanvas.getContext('2d');
+          this.axisCanvas.style.height = `${height}px`;
+          this.axisCanvas.style.width = `${width}px`;
+          this.axisCanvas.height = window.devicePixelRatio * height;
+          this.axisCanvas.width = window.devicePixelRatio * width;
+          this.axisCanvasContext.scale(window.devicePixelRatio, window.devicePixelRatio);
+        }
+      }
+
+      attachDragWidget($track, $viewportContainer) {
+        const self = this;
+        const browser = this.browser;
+        this.$trackDragScrim = $('<div class="igv-track-drag-scrim">');
+        $viewportContainer.append(this.$trackDragScrim);
+        this.$trackDragScrim.hide();
+        self.$trackManipulationHandle = $('<div class="igv-track-manipulation-handle">');
+        $track.append(self.$trackManipulationHandle);
+        self.$trackManipulationHandle.on('mousedown', function (e) {
+          e.preventDefault();
+          e.stopPropagation();
+          self.$trackDragScrim.show();
+          browser.startTrackDrag(self);
+        });
+        self.$trackManipulationHandle.on('mouseup', function (e) {
+          e.preventDefault();
+          e.stopPropagation();
+          browser.endTrackDrag();
+          self.$trackDragScrim.hide();
+        });
+        $track.on('mouseenter', function (e) {
+          if (browser.dragTrack) {
+            e.preventDefault();
+            e.stopPropagation();
+            browser.updateTrackDrag(self);
+          }
+        });
+        self.$trackManipulationHandle.on('mouseleave', function (e) {
+          if (!browser.dragTrack) {
+            e.preventDefault();
+            e.stopPropagation();
+            self.$trackDragScrim.hide();
+          }
+        });
+      }
+
+      viewportsToReload(force) {
+        // List of viewports that need reloading
+        const rpV = this.viewports.filter(function (viewport) {
+          if (!viewport.isVisible()) {
+            return false;
+          }
+
+          if (!viewport.checkZoomIn()) {
+            return false;
+          } else {
+            const referenceFrame = viewport.referenceFrame;
+            const chr = viewport.referenceFrame.chr;
+            const start = referenceFrame.start;
+            const end = start + referenceFrame.toBP($(viewport.contentDiv).width());
+            const bpPerPixel = referenceFrame.bpPerPixel;
+            return force || !viewport.tile || viewport.tile.invalidate || !viewport.tile.containsRange(chr, start, end, bpPerPixel);
+          }
+        });
+        return rpV;
+      }
+      /**
+       * Do any cleanup here
+       */
+
+
+      dispose() {
+        const self = this;
+
+        if (this.$trackManipulationHandle) {
+          this.$trackManipulationHandle.off();
+        }
+
+        if (this.scrollbar) {
+          this.scrollbar.dispose();
+        }
+
+        $(document).off(this.namespace);
+
+        if (typeof this.track.dispose === "function") {
+          this.track.dispose();
+        }
+
+        var track = this.track;
+
+        if (typeof track.dispose === 'function') {
+          track.dispose();
+        }
+
+        Object.keys(track).forEach(function (key) {
+          track[key] = undefined;
+        });
+        this.viewports.forEach(function (viewport) {
+          viewport.dispose();
+        });
+
+        Object.keys(this).forEach(function (key) {
+          self[key] = undefined;
+        });
+
+        if (this.alert) {
+          this.alert.container.remove(); // This is quite obviously a hack, need a "dispose" method on AlertDialog
+        }
+
+        this.disposed = true;
+      }
+
+      scrollBy(delta) {
+        this.scrollbar.moveScrollerBy(delta);
+      }
+
+      appendRightHandGutter($parent) {
+        let $div = $('<div class="igv-right-hand-gutter">');
+        $parent.append($div);
+        this.createTrackGearPopup($div);
+      }
+
+      createTrackGearPopup($parent) {
+        let $container = $("<div>", {
+          class: 'igv-trackgear-container'
+        });
+        $parent.append($container);
+        $container.append(createIcon$1('cog'));
+        this.trackGearPopup = new MenuPopup($parent);
+        this.trackGearPopup.$popover.hide();
+        $container.click(e => {
+          e.preventDefault();
+          e.stopPropagation();
+          this.trackGearPopup.presentMenuList(-this.trackGearPopup.$popover.width(), 0, MenuUtils.trackMenuItemList(this));
+        });
+      }
+
+      static computeViewportWidth(browser, viewportContainerWidth) {
+        return viewportContainerWidth - axisContainerWidth - browser.getSampleNameViewportWidth();
+      }
+
+    }
+
+    function renderSVGAxis(context, track, axisCanvas, deltaX, deltaY) {
+      if (typeof track.paintAxis === 'function') {
+        const {
+          y,
+          width,
+          height
+        } = axisCanvas.getBoundingClientRect();
+        const str = (track.name || track.id).replace(/\W/g, '');
+        const id = `${str}_axis_guid_${guid()}`;
+        context.saveWithTranslationAndClipRect(id, deltaX, y + deltaY, width, height, 0);
+        track.paintAxis(context, width, height);
+        context.restore();
+      }
+    }
+
+    function emptyViewportContainers(trackViews) {
+      for (let trackView of trackViews) {
+        if (trackView.scrollbar) {
+          trackView.scrollbar.$outerScroll.remove();
+          trackView.scrollbar = null;
+          trackView.scrollbar = undefined;
+        }
+
+        for (let viewport of [...trackView.viewports, trackView.sampleNameViewport]) {
+          if (viewport.rulerSweeper) {
+            viewport.rulerSweeper.$rulerSweeper.remove();
+          }
+
+          if (viewport.popover) {
+            viewport.popover.dispose();
+          }
+
+          viewport.$viewport.remove();
+        }
+
+        delete trackView.sampleNameViewport;
+        delete trackView.viewports;
+        delete trackView.scrollbar;
+      }
+    }
+
+    function updateViewportShims(viewports, $viewportContainer) {
+      const $trackContainer = $('.igv-track-container');
+      $trackContainer.find('.igv-multi-locus-separator').remove();
+      const {
+        x: tx
+      } = documentOffset($trackContainer.get(0));
+      $viewportContainer.find('.igv-viewport-multi-locus-gap-shim').remove();
+
+      if (viewports.length > 1) {
+        for (let viewport of viewports) {
+          if (viewports.indexOf(viewport) <= viewports.length - 2) {
+            const {
+              $viewport
+            } = viewport;
+            const $shim = $('<div class="igv-viewport-multi-locus-gap-shim">');
+            $shim.insertAfter($viewport);
+            const {
+              x: sx
+            } = documentOffset($shim.get(0)); // console.log(`trackContainer x ${ tx }. shim x ${ sx }`)
+
+            const $multilLocusSeparator = $('<div class="igv-multi-locus-separator">');
+            $trackContainer.append($multilLocusSeparator);
+            $multilLocusSeparator.get(0).style.left = `${sx - tx}px`;
+          }
+        }
+      }
+    }
+
+    function documentOffset(el) {
+      const {
+        x,
+        y
+      } = el.getBoundingClientRect();
+      const scrollX = window.pageXOffset || document.documentElement.scrollLeft;
+      const scrollY = window.pageYOffset || document.documentElement.scrollTop;
+      return {
+        x: x + scrollX,
+        y: y + scrollY
+      };
+    }
+
+    function maxViewportContentHeight(viewports) {
+      const heights = viewports.filter(viewport => !(viewport.trackView.sampleNameViewport === viewport)).map(viewport => viewport.getContentHeight());
+      return Math.max(...heights);
+    }
+
+    /**
+     * Decoder for bedpe records.
+     *
+     * Bedpe format was created by Aaron Quinlan et al as part of the bedtools project.
+     * The spec is here:  https://bedtools.readthedocs.io/en/latest/content/general-usage.html,  however there
+     * are off spec variants, an important one being a 7 column format with score in place of the standard
+     * name column.
+     *
+     * Another common variant is a "hiccups" output file, which is standard bedpe with the exception of a header line
+     * of the form
+     * chr1    x1    x2    chr2    y1    y2    name    score    strand1    strand2    color    observed    expectedBL    expectedDonut    expectedH    expectedV    fdrBL    fdrDonut    fdrH    fdrV
+     *
+     * @param tokens
+     * @param ignore
+     * @returns {{start1: number, end2: number, end1: number, chr1: *, chr2: *, start2: number}|undefined}
+     */
+
+    function decodeBedpe(tokens, header) {
+      if (tokens.length < 6) {
+        return undefined;
+      }
+
+      var feature = {
+        chr1: tokens[0],
+        start1: Number.parseInt(tokens[1]),
+        end1: Number.parseInt(tokens[2]),
+        chr2: tokens[3],
+        start2: Number.parseInt(tokens[4]),
+        end2: Number.parseInt(tokens[5])
+      };
+
+      if (isNaN(feature.start1) || isNaN(feature.end1) || isNaN(feature.start2) || isNaN(feature.end2)) {
+        //throw Error(`Error parsing line: ${tokens.join('\t')}`);
+        return undefined;
+      }
+
+      if (tokens.length > 6 && tokens[6] !== ".") {
+        feature.name = tokens[6];
+      }
+
+      if (tokens.length > 7 && tokens[7] !== ".") {
+        feature.score = parseFloat(tokens[7]);
+      }
+
+      if (tokens.length > 8 && tokens[8] !== ".") {
+        feature.strand1 = tokens[8];
+      }
+
+      if (tokens.length > 9 && tokens[9] !== ".") {
+        feature.strand2 = tokens[9];
+      } // Optional extra columns
+
+
+      if (header) {
+        const colorColumn = header.colorColumn;
+
+        if (colorColumn && colorColumn < tokens.length) {
+          feature.color = IGVColor.createColorString(tokens[colorColumn]);
+        }
+
+        const thicknessColumn = header.thicknessColumn;
+
+        if (thicknessColumn && thicknessColumn < tokens.length) {
+          feature.thickness = tokens[thicknessColumn];
+        }
+
+        if (tokens.length > 10 && header.columnNames && header.columnNames.length === tokens.length) {
+          feature.extras = tokens.slice(10);
+        }
+      } // Set total extent of feature
+
+
+      if (feature.chr1 === feature.chr2) {
+        feature.chr = feature.chr1;
+        feature.start = Math.min(feature.start1, feature.start2);
+        feature.end = Math.max(feature.end1, feature.end2);
+      }
+
+      return feature;
+    }
+    /**
+     * Hack for non-standard bedPE formats, where numeric score can be in column 7 (name field from spec)
+     * @param features
+     */
+
+
+    function fixBedPE(features) {
+      if (features.length == 0) return; // Assume all features have same properties
+
+      const firstFeature = features[0];
+
+      if (firstFeature.score === undefined && firstFeature.name !== undefined) {
+        // Name field (col 7) is sometimes used for score.
+        for (let f of features) {
+          if (!(isNumber(f.name) || f.name === '.')) return;
+        }
+
+        for (let f of features) {
+          f.score = parseFloat(f.name);
+          delete f.name;
+        }
+      } // Make copies of inter-chr features, one for each chromosome
+
+
+      const interChrFeatures = features.filter(f => f.chr1 !== f.chr2);
+
+      for (let f1 of interChrFeatures) {
+        const f2 = Object.assign({}, f1);
+        f2.dup = true;
+        features.push(f2);
+        f1.chr = f1.chr1;
+        f1.start = f1.start1;
+        f1.end = f1.end1;
+        f2.chr = f2.chr2;
+        f2.start = f2.start2;
+        f2.end = f2.end2;
+      }
+    }
+    /**
+     * Special decoder for Hic Domain files.   In these files feature1 == feature2, they are really bed records.
+     * @param tokens
+     * @param ignore
+     * @returns {*}
+     */
+
+
+    function decodeBedpeDomain(tokens, header) {
+      if (tokens.length < 8) return undefined;
+      return {
+        chr: tokens[0],
+        start: Number.parseInt(tokens[1]),
+        end: Number.parseInt(tokens[2]),
+        color: IGVColor.createColorString(tokens[6]),
+        value: Number.parseFloat(tokens[7])
+      };
+    }
+
+    /**
+     * Decode UCSC "interact" files.  See https://genome.ucsc.edu/goldenpath/help/interact.html
+     *
+     0  string chrom;        "Chromosome (or contig, scaffold, etc.). For interchromosomal, use 2 records"
+     1  uint chromStart;     "Start position of lower region. For interchromosomal, set to chromStart of this region"
+     2  uint chromEnd;       "End position of upper region. For interchromosomal, set to chromEnd of this region"
+     3  string name;         "Name of item, for display.  Usually 'sourceName/targetName/exp' or empty"
+     4  uint score;          "Score (0-1000)"
+     5  double value;        "Strength of interaction or other data value. Typically basis for score"
+     6  string exp;          "Experiment name (metadata for filtering). Use . if not applicable"
+     7  string color;        "Item color.  Specified as r,g,b or hexadecimal #RRGGBB or html color name, as in //www.w3.org/TR/css3-color/#html4. Use 0 and spectrum setting to shade by score"
+     8  string sourceChrom;  "Chromosome of source region (directional) or lower region. For non-directional interchromosomal, chrom of this region."
+     9  uint sourceStart;    "Start position in chromosome of source/lower/this region"
+     10 uint sourceEnd;      "End position in chromosome of source/lower/this region"
+     11 string sourceName;   "Identifier of source/lower/this region"
+     12 string sourceStrand; "Orientation of source/lower/this region: + or -.  Use . if not applicable"
+     13 string targetChrom;  "Chromosome of target region (directional) or upper region. For non-directional interchromosomal, chrom of other region"
+     14 uint targetStart;    "Start position in chromosome of target/upper/this region"
+     15 uint targetEnd;      "End position in chromosome of target/upper/this region"
+     16 string targetName;   "Identifier of target/upper/this region"
+     17 string targetStrand; "Orientation of target/upper/this region: + or -.  Use . if not applicable"
+     *
+     * @param tokens
+     * @param ignore
+     * @returns {*}
+     */
+
+    function decodeInteract(tokens, header) {
+      if (tokens.length < 6) {
+        return undefined;
+      }
+
+      var feature = {
+        chr: tokens[0],
+        start: tokens[1],
+        end: tokens[2],
+        chr1: tokens[8],
+        start1: Number.parseInt(tokens[9]),
+        end1: Number.parseInt(tokens[10]),
+        chr2: tokens[13],
+        start2: Number.parseInt(tokens[14]),
+        end2: Number.parseInt(tokens[15]),
+        name: tokens[3],
+        score: Number.parseFloat(tokens[4]),
+        value: Number.parseFloat(tokens[5]),
+        color: tokens[7] === '.' ? undefined : tokens[7] === "0" ? "rgb(0,0,0)" : tokens[7]
+      };
+      return feature;
+    }
+
+    const gffNameFields = ["Name", "gene_name", "gene", "gene_id", "alias", "locus", "name"];
+    /**
+     * Decode a single gff record (1 line in file).  Aggregations such as gene models are constructed at a higher level.
+     *      ctg123 . mRNA            1050  9000  .  +  .  ID=mRNA00001;Parent=gene00001
+     * @param tokens
+     * @param ignore
+     * @returns {*}
+     */
+
+    function decodeGFF(tokens, header) {
+      var tokenCount,
+          chr,
+          start,
+          end,
+          strand,
+          type,
+          score,
+          attributeString,
+          color,
+          name,
+          i,
+          format = header.format;
+      tokenCount = tokens.length;
+
+      if (tokenCount < 9) {
+        return null; // Not a valid gff record
+      }
+
+      chr = tokens[0];
+      type = tokens[2];
+      start = parseInt(tokens[3]) - 1;
+      end = parseInt(tokens[4]);
+      score = "." === tokens[5] ? 0 : parseFloat(tokens[5]);
+      strand = tokens[6];
+      "." === tokens[7] ? 0 : parseInt(tokens[7]);
+      attributeString = tokens[8]; // Find ID and Parent, or transcript_id
+
+      var delim = 'gff3' === format ? '=' : /\s+/;
+      var attributes = parseAttributeString(attributeString, delim);
+
+      for (let [key, value] of Object.entries(attributes)) {
+        const keyLower = key.toLowerCase();
+
+        if ("color" === keyLower || "colour" === keyLower) {
+          color = IGVColor.createColorString(value);
+        } else if ('gff3' === format) try {
+          attributes[key] = unescape(value);
+        } catch (e) {
+          attributes[key] = value; // Invalid
+
+          console.error(`Malformed gff3 attibute value: ${value}`);
+        }
+      } // Find name (label) property
+
+
+      if (header.nameField) {
+        name = attributes[header.nameField];
+      } else {
+        for (i = 0; i < gffNameFields.length; i++) {
+          if (attributes.hasOwnProperty(gffNameFields[i])) {
+            header.nameField = gffNameFields[i];
+            name = attributes[header.nameField];
+            break;
+          }
+        }
+      }
+
+      const id = attributes["ID"] || attributes["transcript_id"];
+      const parent = attributes["Parent"];
+      return {
+        id: id,
+        parent: parent,
+        name: name,
+        type: type,
+        chr: chr,
+        start: start,
+        end: end,
+        score: score,
+        strand: strand,
+        color: color,
+        attributeString: attributeString,
+        delim: delim,
+        popupData: popupData
+      };
+    }
+
+    function parseAttributeString(attributeString, keyValueDelim) {
+      // parse 'attributes' string (see column 9 docs in https://github.com/The-Sequence-Ontology/Specifications/blob/master/gff3.md)
+      var attributes = {};
+
+      for (let kv of attributeString.split(';')) {
+        const t = kv.trim().split(keyValueDelim, 2);
+
+        if (t.length === 2) {
+          const key = t[0].trim();
+          let value = t[1].trim(); //Strip off quotes, if any
+
+          if (value.startsWith('"') && value.endsWith('"')) {
+            value = value.substr(1, value.length - 2);
+          }
+
+          attributes[key] = value;
+        }
+      }
+
+      return attributes;
+    }
+
+    function popupData(genomicLocation) {
+      const kvs = this.attributeString.split(';');
+      const pd = [];
+
+      if (this.name) {
+        pd.push({
+          name: 'name:',
+          value: this.name
+        });
+      }
+
+      pd.push({
+        name: 'type:',
+        value: this.type
+      });
+
+      for (let kv of kvs) {
+        const t = kv.trim().split(this.delim, 2);
+
+        if (t.length === 2 && t[1] !== undefined) {
+          const key = t[0].trim();
+          if ('name' === key.toLowerCase()) continue;
+          let value = t[1].trim(); //Strip off quotes, if any
+
+          if (value.startsWith('"') && value.endsWith('"')) {
+            value = value.substr(1, value.length - 2);
+          }
+
+          pd.push({
+            name: key + ":",
+            value: value
+          });
+        }
+      }
+
+      pd.push({
+        name: 'position:',
+        value: `${this.chr}:${numberFormatter$1(this.start + 1)}-${numberFormatter$1(this.end)}`
+      });
+      return pd;
+    }
+
+    /**
+     * Wrapper class to record a decoding error.
+     */
+    class DecodeError {
+      constructor(message) {
+        this.message = message;
+      }
+
+    }
+
+    /**
+     * Decode the UCSC bed format.  Only the first 3 columns (chr, start, end) are required.   The remaining columns
+     * must follow standard bed order, but we will tolerate deviations after column 3.
+     *
+     * @param tokens
+     * @param ignore
+     * @returns decoded feature, or null if this is not a valid record
+     */
+
+    function decodeBed(tokens, header) {
+      if (tokens.length < 3) return undefined;
+      header && header.gffTags;
+      const chr = tokens[0];
+      const start = parseInt(tokens[1]);
+      const end = tokens.length > 2 ? parseInt(tokens[2]) : start + 1;
+
+      if (isNaN(start) || isNaN(end)) {
+        return new DecodeError(`Unparsable bed record.`);
+      }
+
+      const feature = {
+        chr: chr,
+        start: start,
+        end: end,
+        score: 1000
+      };
+
+      try {
+        if (tokens.length > 3) {
+          // Note: these are very special rules for the gencode gene files.
+          // tmp = tokens[3].replace(/"/g, '');
+          // idName = tmp.split(';');
+          // for (var i = 0; i < idName.length; i++) {
+          //     var kv = idName[i].split('=');
+          //     if (kv[0] == "gene_id") {
+          //         id = kv[1];
+          //     }
+          //     if (kv[0] == "gene_name") {
+          //         name = kv[1];
+          //     }
+          // }
+          // feature.id = id ? id : tmp;
+          // feature.name = name ? name : tmp;
+          //parse gffTags in the name field
+          if (tokens[3].indexOf(';') > 0 && tokens[3].indexOf('=') > 0) {
+            const attributes = parseAttributeString(tokens[3], '=');
+
+            for (let nmField of gffNameFields) {
+              if (attributes.hasOwnProperty(nmField)) {
+                feature.name = attributes[nmField];
+                delete attributes[nmField];
+                break;
+              }
+            }
+
+            feature.attributes = attributes;
+          }
+
+          if (!feature.name) {
+            feature.name = tokens[3] === '.' ? '' : tokens[3];
+          }
+        }
+
+        if (tokens.length > 4) {
+          feature.score = tokens[4] === '.' ? 0 : parseFloat(tokens[4]);
+
+          if (isNaN(feature.score)) {
+            return feature;
+          }
+        }
+
+        if (tokens.length > 5) {
+          feature.strand = tokens[5];
+
+          if (!(feature.strand === '.' || feature.strand === '+' || feature.strand === '-')) {
+            return feature;
+          }
+        }
+
+        if (tokens.length > 6) {
+          feature.cdStart = parseInt(tokens[6]);
+
+          if (isNaN(feature.cdStart)) {
+            return feature;
+          }
+        }
+
+        if (tokens.length > 7) {
+          feature.cdEnd = parseInt(tokens[7]);
+
+          if (isNaN(feature.cdEnd)) {
+            return feature;
+          }
+        }
+
+        if (tokens.length > 8) {
+          if (tokens[8] !== "." && tokens[8] !== "0") feature.color = IGVColor.createColorString(tokens[8]);
+        }
+
+        if (tokens.length > 11) {
+          const exonCount = parseInt(tokens[9]); // Some basic validation
+
+          if (exonCount > 1000) {
+            // unlikely
+            return feature;
+          }
+
+          const exonSizes = tokens[10].replace(/,$/, '').split(',');
+          const exonStarts = tokens[11].replace(/,$/, '').split(',');
+
+          if (!(exonSizes.length === exonStarts.length && exonCount === exonSizes.length)) {
+            return feature;
+          }
+
+          const exons = [];
+
+          for (let i = 0; i < exonCount; i++) {
+            const eStart = start + parseInt(exonStarts[i]);
+            const eEnd = eStart + parseInt(exonSizes[i]);
+            exons.push({
+              start: eStart,
+              end: eEnd
+            });
+          }
+
+          findUTRs(exons, feature.cdStart, feature.cdEnd);
+          feature.exons = exons;
+        } // Optional extra columns
+
+
+        if (header) {
+          let thicknessColumn = header.thicknessColumn;
+          let colorColumn = header.colorColumn;
+
+          if (colorColumn && colorColumn < tokens.length) {
+            feature.color = IGVColor.createColorString(tokens[colorColumn]);
+          }
+
+          if (thicknessColumn && thicknessColumn < tokens.length) {
+            feature.thickness = tokens[thicknessColumn];
+          }
+        }
+      } catch (e) {}
+
+      return feature;
+    }
+    /**
+     * Decode a UCSC repeat masker record.
+     *
+     * Columns, from UCSC documentation
+     *
+     * 0  bin    585    smallint(5) unsigned    Indexing field to speed chromosome range queries.
+     * 1  swScore    1504    int(10) unsigned    Smith Waterman alignment score
+     * 2  milliDiv    13    int(10) unsigned    Base mismatches in parts per thousand
+     * 3  milliDel    4    int(10) unsigned    Bases deleted in parts per thousand
+     * 4  milliIns    13    int(10) unsigned    Bases inserted in parts per thousand
+     * 5  genoName    chr1    varchar(255)    Genomic sequence name
+     * 6  genoStart    10000    int(10) unsigned    Start in genomic sequence
+     * 7  genoEnd    10468    int(10) unsigned    End in genomic sequence
+     * 8  genoLeft    -249240153    int(11)    -#bases after match in genomic sequence
+     * 9  strand    +    char(1)    Relative orientation + or -
+     * 10 repName    (CCCTAA)n    varchar(255)    Name of repeat
+     * 11 repClass    Simple_repeat    varchar(255)    Class of repeat
+     * 12 repFamily    Simple_repeat    varchar(255)    Family of repeat
+     * 13 repStart    1    int(11)    Start (if strand is +) or -#bases after match (if strand is -) in repeat sequence
+     * 14 repEnd    463    int(11)    End in repeat sequence
+     * 15 repLeft    0    int(11)    -#bases after match (if strand is +) or start (if strand is -) in repeat sequence
+     * 16 id    1    char(1)    First digit of id field in RepeatMasker .out file. Best ignored.
+     */
+
+
+    function decodeRepeatMasker(tokens, header) {
+      if (tokens.length <= 15) return undefined;
+      const feature = {
+        swScore: Number.parseInt(tokens[1]),
+        milliDiv: Number.parseInt(tokens[2]),
+        milliDel: Number.parseInt(tokens[3]),
+        milliIns: Number.parseInt(tokens[4]),
+        chr: tokens[5],
+        start: Number.parseInt(tokens[6]),
+        end: Number.parseInt(tokens[7]),
+        //genoLeft: tokens[8],
+        strand: tokens[9],
+        repName: tokens[10],
+        repClass: tokens[11],
+        repFamily: tokens[12],
+        repStart: Number.parseInt(tokens[13]),
+        repEnd: Number.parseInt(tokens[14]),
+        repLeft: Number.parseInt(tokens[15])
+      };
+      return feature;
+    }
+    /**
+     * Decode a UCSC "genePred" record.
+     *
+     * @param tokens
+     * @param ignore
+     * @returns {*}
+     */
+
+
+    function decodeGenePred(tokens, header) {
+      var shift = header.shift === undefined ? 0 : 1;
+      if (tokens.length <= 9 + shift) return undefined;
+      const cdStart = parseInt(tokens[5 + shift]);
+      const cdEnd = parseInt(tokens[6 + shift]);
+      var feature = {
+        name: tokens[0 + shift],
+        chr: tokens[1 + shift],
+        strand: tokens[2 + shift],
+        start: parseInt(tokens[3 + shift]),
+        end: parseInt(tokens[4 + shift]),
+        cdStart: cdStart,
+        cdEnd: cdEnd,
+        id: tokens[0 + shift]
+      },
+          exonCount = parseInt(tokens[7 + shift]),
+          exonStarts = tokens[8 + shift].split(','),
+          exonEnds = tokens[9 + shift].split(','),
+          exons = [];
+
+      for (let i = 0; i < exonCount; i++) {
+        const start = parseInt(exonStarts[i]);
+        const end = parseInt(exonEnds[i]);
+        exons.push({
+          start: start,
+          end: end
+        });
+      }
+
+      findUTRs(exons, cdStart, cdEnd);
+      feature.exons = exons;
+      return feature;
+    }
+    /**
+     * Decode a UCSC "genePredExt" record.  refGene files are in this format.
+     *
+     * @param tokens
+     * @param ignore
+     * @returns {*}
+     */
+
+
+    function decodeGenePredExt(tokens, header) {
+      var shift = header.shift === undefined ? 0 : 1;
+      if (tokens.length <= 11 + shift) return undefined;
+      const cdStart = parseInt(tokens[5 + shift]);
+      const cdEnd = parseInt(tokens[6 + shift]);
+      const feature = {
+        name: tokens[11 + shift],
+        chr: tokens[1 + shift],
+        strand: tokens[2 + shift],
+        start: parseInt(tokens[3 + shift]),
+        end: parseInt(tokens[4 + shift]),
+        cdStart: cdStart,
+        cdEnd: cdEnd,
+        id: tokens[0 + shift]
+      },
+            exonCount = parseInt(tokens[7 + shift]),
+            exonStarts = tokens[8 + shift].split(','),
+            exonEnds = tokens[9 + shift].split(','),
+            exons = [];
+
+      for (let i = 0; i < exonCount; i++) {
+        const start = parseInt(exonStarts[i]);
+        const end = parseInt(exonEnds[i]);
+        exons.push({
+          start: start,
+          end: end
+        });
+      }
+
+      findUTRs(exons, cdStart, cdEnd);
+      feature.exons = exons;
+      return feature;
+    }
+    /**
+     * Decode a UCSC "refFlat" record
+     * @param tokens
+     * @param ignore
+     * @returns {*}
+     */
+
+
+    function decodeReflat(tokens, header) {
+      var shift = header.shift === undefined ? 0 : 1;
+      if (tokens.length <= 10 + shift) return undefined;
+      const cdStart = parseInt(tokens[6 + shift]);
+      const cdEnd = parseInt(tokens[7 + shift]);
+      var feature = {
+        name: tokens[0 + shift],
+        id: tokens[1 + shift],
+        chr: tokens[2 + shift],
+        strand: tokens[3 + shift],
+        start: parseInt(tokens[4 + shift]),
+        end: parseInt(tokens[5 + shift]),
+        cdStart: cdStart,
+        cdEnd: cdEnd
+      },
+          exonCount = parseInt(tokens[8 + shift]),
+          exonStarts = tokens[9 + shift].split(','),
+          exonEnds = tokens[10 + shift].split(','),
+          exons = [];
+
+      for (let i = 0; i < exonCount; i++) {
+        const start = parseInt(exonStarts[i]);
+        const end = parseInt(exonEnds[i]);
+        exons.push({
+          start: start,
+          end: end
+        });
+      }
+
+      findUTRs(exons, cdStart, cdEnd);
+      feature.exons = exons;
+      return feature;
+    }
+
+    function findUTRs(exons, cdStart, cdEnd) {
+      for (let exon of exons) {
+        const end = exon.end;
+        const start = exon.start;
+
+        if (end < cdStart || start > cdEnd) {
+          exon.utr = true;
+        } else {
+          if (cdStart >= start && cdStart <= end) {
+            exon.cdStart = cdStart;
+          }
+
+          if (cdEnd >= start && cdEnd <= end) {
+            exon.cdEnd = cdEnd;
+          }
+        }
+      }
+    }
+
+    function decodePeak(tokens, header) {
+      var tokenCount, chr, start, end, strand, name, score, qValue, signal, pValue;
+      tokenCount = tokens.length;
+
+      if (tokenCount < 9) {
+        return undefined;
+      }
+
+      chr = tokens[0];
+      start = parseInt(tokens[1]);
+      end = parseInt(tokens[2]);
+      name = tokens[3];
+      score = parseFloat(tokens[4]);
+      strand = tokens[5].trim();
+      signal = parseFloat(tokens[6]);
+      pValue = parseFloat(tokens[7]);
+      qValue = parseFloat(tokens[8]);
+      if (score === 0) score = signal;
+      return {
+        chr: chr,
+        start: start,
+        end: end,
+        name: name,
+        score: score,
+        strand: strand,
+        signal: signal,
+        pValue: pValue,
+        qValue: qValue
+      };
+    }
+
+    function decodeBedGraph(tokens, header) {
+      var chr, start, end, value;
+      if (tokens.length <= 3) return undefined;
+      chr = tokens[0];
+      start = parseInt(tokens[1]);
+      end = parseInt(tokens[2]);
+      value = parseFloat(tokens[3]);
+      const feature = {
+        chr: chr,
+        start: start,
+        end: end,
+        value: value
+      }; // Optional extra columns
+
+      if (header) {
+        let colorColumn = header.colorColumn;
+
+        if (colorColumn && colorColumn < tokens.length) {
+          feature.color = IGVColor.createColorString(tokens[colorColumn]);
+        }
+      }
+
+      return feature;
+    }
+
+    function decodeWig(tokens, header) {
+      const wig = header.wig;
+
+      if (wig && wig.format === "fixedStep") {
+        const ss = wig.index * wig.step + wig.start;
+        const ee = ss + wig.span;
+        const value = parseFloat(tokens[0]);
+        ++wig.index;
+        return isNaN(value) ? null : {
+          chr: wig.chrom,
+          start: ss,
+          end: ee,
+          value: value
+        };
+      } else if (wig && wig.format === "variableStep") {
+        if (tokens.length < 2) return null;
+        const ss = parseInt(tokens[0], 10) - 1;
+        const ee = ss + wig.span;
+        const value = parseFloat(tokens[1]);
+        return isNaN(value) ? null : {
+          chr: wig.chrom,
+          start: ss,
+          end: ee,
+          value: value
+        };
+      } else {
+        return decodeBedGraph(tokens);
+      }
+    }
+
+    function decodeSNP(tokens, header) {
+      if (tokens.length < 6) return undefined;
+      const autoSql = ['bin', 'chr', 'start', 'end', 'name', 'score', 'strand', 'refNCBI', 'refUCSC', 'observed', 'molType', 'class', 'valid', 'avHet', 'avHetSE', 'func', 'locType', 'weight', 'exceptions', 'submitterCount', 'submitters', 'alleleFreqCount', 'alleles', 'alleleNs', 'alleleFreqs', 'bitfields'];
+      const feature = {
+        chr: tokens[1],
+        start: Number.parseInt(tokens[2]),
+        end: Number.parseInt(tokens[3]),
+        name: tokens[4],
+        score: Number.parseInt(tokens[5])
+      };
+      const n = Math.min(tokens.length, autoSql.length);
+
+      for (let i = 6; i < n; i++) {
+        feature[autoSql[i]] = tokens[i];
+      }
+
+      return feature;
+    }
+
+    function decodeFusionJuncSpan(tokens, header) {
+      /*
+       Format:
+        0       #scaffold
+       1       fusion_break_name
+       2       break_left
+       3       break_right
+       4       num_junction_reads
+       5       num_spanning_frags
+       6       spanning_frag_coords
+        0       B3GNT1--NPSR1
+       1       B3GNT1--NPSR1|2203-10182
+       2       2203
+       3       10182
+       4       189
+       5       1138
+       6       1860-13757,1798-13819,1391-18127,1443-17174,...
+        */
+      if (tokens.length < 7) return undefined;
+      var chr = tokens[0];
+      var fusion_name = tokens[1];
+      var junction_left = parseInt(tokens[2]);
+      var junction_right = parseInt(tokens[3]);
+      var num_junction_reads = parseInt(tokens[4]);
+      var num_spanning_frags = parseInt(tokens[5]);
+      var spanning_frag_coords_text = tokens[6];
+      var feature = {
+        chr: chr,
+        name: fusion_name,
+        junction_left: junction_left,
+        junction_right: junction_right,
+        num_junction_reads: num_junction_reads,
+        num_spanning_frags: num_spanning_frags,
+        spanning_frag_coords: [],
+        start: -1,
+        end: -1
+      }; // set start and end later based on min/max of span coords
+
+      var min_coord = junction_left;
+      var max_coord = junction_right;
+
+      if (num_spanning_frags > 0) {
+        var coord_pairs = spanning_frag_coords_text.split(',');
+
+        for (var i = 0; i < coord_pairs.length; i++) {
+          var split_coords = coord_pairs[i].split('-');
+          var span_left = split_coords[0];
+          var span_right = split_coords[1];
+
+          if (span_left < min_coord) {
+            min_coord = span_left;
+          }
+
+          if (span_right > max_coord) {
+            max_coord = span_right;
+          }
+
+          feature.spanning_frag_coords.push({
+            left: span_left,
+            right: span_right
+          });
+        }
+      }
+
+      feature.start = min_coord;
+      feature.end = max_coord;
+      return feature;
+    }
+
+    function decodeGtexGWAS(tokens, header) {
+      //chrom	chromStart	chromEnd	Strongest SNP-risk allele	Disease/Phenotype	P-value	Odds ratio or beta	PUBMEDID
+      //1	1247493	1247494	rs12103-A	Inflammatory bowel disease	8.00E-13	1.1	23128233
+      const tokenCount = tokens.length;
+
+      if (tokenCount < 7) {
+        return null;
+      }
+
+      const feature = {
+        chr: tokens[0],
+        start: parseInt(tokens[1]) - 1,
+        end: parseInt(tokens[2]),
+        'Strongest SNP-risk allele': tokens[3],
+        'Disease/Phenotype': tokens[4],
+        'P-value': tokens[5],
+        'Odds ratio or beta': tokens[6]
+      };
+
+      if (tokens.length > 6) {
+        feature['PUBMEDID'] = `<a target = "blank" href = "https://www.ncbi.nlm.nih.gov/pubmed/${tokens[7]}">${tokens[7]}</a>`;
+      }
+
+      return feature;
+    }
+
+    /**
+     * Decode a custom columnar format.  Required columns are 'chr' and 'start'
+     *
+     * @param tokens
+     * @param ignore
+     * @returns decoded feature, or null if this is not a valid record
+     */
+    function decodeCustom(tokens, header) {
+      const format = header.customFormat;
+      if (tokens.length < format.fields.length) return undefined;
+      const coords = format.coords || 0;
+      const chr = tokens[format.chr];
+      const start = parseInt(tokens[format.start]) - coords;
+      const end = format.end !== undefined ? parseInt(tokens[format.end]) : start + 1;
+      const feature = {
+        chr: chr,
+        start: start,
+        end: end
+      };
+
+      if (format.fields) {
+        format.fields.forEach(function (field, index) {
+          if (index !== format.chr && index !== format.start && index !== format.end) {
+            feature[field] = tokens[index];
+          }
+        });
+      }
+
+      return feature;
+    } // function expandFormat(format) {
+
+    /**
+     * Decode a gcnv record, a bed style format encoding copy number variation
+     *
+     * @param tokens
+     * @param header
+     */
+    function decodeGcnv(tokens, header) {
+      const columnNames = header.columnNames;
+
+      if (!columnNames) {
+        throw Error("Sample names are not defined.   Missing column headers?");
+      }
+
+      const sampleCount = columnNames.length - 3;
+      const chr = tokens[0];
+      const start = parseInt(tokens[1]);
+      const end = parseInt(tokens[2]);
+      const values = tokens.slice(3).map(parseFloat);
+
+      if (values.length == sampleCount) {
+        return {
+          chr: chr,
+          start: start,
+          end: end,
+          values: values
+        };
+      } else {
+        // TODO Throw error?
+        console.warn(`${chr}:${start}-${end} row contains ${values.length} sample columns instead of the expected ${sampleCount} columns. Skipping...`);
+        return undefined;
+      }
+    }
+
+    /*
+     * The MIT License (MIT)
+     *
+     * Copyright (c) 2014 Broad Institute
+     *
+     * Permission is hereby granted, free of charge, to any person obtaining a copy
+     * of this software and associated documentation files (the "Software"), to deal
+     * in the Software without restriction, including without limitation the rights
+     * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+     * copies of the Software, and to permit persons to whom the Software is
+     * furnished to do so, subject to the following conditions:
+     *
+     * The above copyright notice and this permission notice shall be included in
+     * all copies or substantial portions of the Software.
+     *
+     *
+     * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+     * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+     * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+     * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+     * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+     * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+     * THE SOFTWARE.
+     */
+    /**
+     *  Parser for column style (tab delimited, etc) text file formats (bed, gff, vcf, etc).
+     *
+     *
+     */
+
+    /**
+     * Return a parser for the given file format.
+     */
+
+    class FeatureParser {
+      constructor(config) {
+        this.config = config;
+        this.header = {};
+
+        if (config.nameField) {
+          this.header.nameField = config.nameField;
+        }
+
+        this.skipRows = 0; // The number of fixed header rows to skip.  Override for specific types as needed
+
+        if (config.decode) {
+          this.decode = config.decode;
+          this.delimiter = config.delimiter || "\t";
+        } else if (config.format) {
+          this.header.format = config.format.toLowerCase();
+          this.setDecoder(this.header.format);
+        }
+
+        if (!this.delimiter) {
+          this.delimiter = "\t";
+        }
+      }
+      /**
+       * Parse metadata from the file.   A variety of conventions are in use to supply metadata about file contents
+       * through header lines (e.g. 'track') and # directives. This method unifies metadata as properties of a
+       * 'header' object.
+       *
+       * @param data
+       * @returns {{}}
+       */
+
+
+      async parseHeader(dataWrapper) {
+        let header = this.header;
+        let columnNames;
+        let line;
+
+        while ((line = await dataWrapper.nextLine()) !== undefined) {
+          if (line.startsWith("track") || line.startsWith("#track")) {
+            let h = parseTrackLine$1(line);
+            Object.assign(header, h);
+          } else if (line.startsWith("browser")) ; else if (line.startsWith("#columns")) {
+            let h = parseColumnsDirective$1(line);
+            Object.assign(header, h);
+          } else if (line.startsWith("##gff-version 3")) {
+            header.format = "gff3";
+          } else if (line.startsWith("#gffTags")) {
+            header.gffTags = true;
+          } else if (line.startsWith("fixedStep") || line.startsWith("variableStep")) {
+            // Wig directives -- we are in the data section
+            break;
+          } else if (line.startsWith("#")) {
+            const tokens = line.split(this.delimiter || "\t");
+
+            if (tokens.length > 1) {
+              columnNames = tokens; // Possible column names
+            }
+          } else {
+            // All directives that could change the format, and thus decoder, should have been read by now.
+            this.setDecoder(header.format); // If the line can be parsed as a feature assume we are beyond the header, if any
+
+            const tokens = line.split(this.delimiter || "\t");
+
+            try {
+              const tmpHeader = Object.assign({
+                columnNames
+              }, header);
+
+              if (this.decode(tokens, tmpHeader)) {
+                break;
+              } else {
+                if (tokens.length > 1) {
+                  columnNames = tokens; // possible column names
+                }
+              }
+            } catch (e) {
+              // Not a feature
+              if (tokens.length > 1) {
+                columnNames = tokens; // possible column names
+              }
+            }
+          }
+        }
+
+        if (columnNames) {
+          header.columnNames = columnNames;
+
+          for (let n = 0; n < columnNames.length; n++) {
+            if (columnNames[n] === "color" || columnNames[n] === "colour") {
+              header.colorColumn = n;
+            } else if (columnNames[n] === "thickness") {
+              header.thicknessColumn = n;
+            }
+          }
+        }
+
+        this.header = header; // Directives might be needed for parsing lines
+
+        return header;
+      }
+
+      async parseFeatures(dataWrapper) {
+        const allFeatures = [];
+        const decode = this.decode;
+        const format = this.header.format;
+        const delimiter = this.delimiter || "\t";
+        let i = 0;
+        let errorCount = 0;
+        let line;
+
+        while ((line = await dataWrapper.nextLine()) !== undefined) {
+          i++;
+          if (i <= this.skipRows) continue;
+
+          if (!line || line.startsWith("track") || line.startsWith("#") || line.startsWith("browser")) {
+            continue;
+          } else if (format === "wig" && line.startsWith("fixedStep")) {
+            this.header.wig = parseFixedStep(line);
+            continue;
+          } else if (format === "wig" && line.startsWith("variableStep")) {
+            this.header.wig = parseVariableStep(line);
+            continue;
+          }
+
+          const tokens = line.split(delimiter);
+
+          if (tokens.length < 1) {
+            continue;
+          }
+
+          const feature = decode(tokens, this.header);
+
+          if (feature instanceof DecodeError) {
+            errorCount++;
+
+            if (errorCount > 0) {
+              console.error(`Error parsing line '${line}': ${feature.message}`);
+            }
+
+            continue;
+          }
+
+          if (feature) {
+            allFeatures.push(feature);
+          }
+        } // Special hack for bedPE
+
+
+        if (decode === decodeBedpe) {
+          fixBedPE(allFeatures);
+        }
+
+        return allFeatures;
+      }
+
+      setDecoder(format) {
+        switch (format) {
+          case "narrowpeak":
+          case "broadpeak":
+          case "regionpeak":
+          case "peaks":
+            this.decode = decodePeak;
+            this.delimiter = this.config.delimiter || /\s+/;
+            break;
+
+          case "bedgraph":
+            this.decode = decodeBedGraph;
+            this.delimiter = /\s+/;
+            break;
+
+          case "wig":
+            this.decode = decodeWig;
+            this.delimiter = this.config.delimiter || /\s+/;
+            break;
+
+          case "gff3":
+          case "gff":
+          case "gtf":
+            this.decode = decodeGFF;
+            this.delimiter = "\t";
+            break;
+
+          case "fusionjuncspan":
+            // bhaas, needed for FusionInspector view
+            this.decode = decodeFusionJuncSpan;
+            this.delimiter = this.config.delimiter || /\s+/;
+            break;
+
+          case "gtexgwas":
+            this.skipRows = 1;
+            this.decode = decodeGtexGWAS;
+            this.delimiter = "\t";
+            break;
+
+          case "refflat":
+            this.decode = decodeReflat;
+            this.delimiter = this.config.delimiter || /\s+/;
+            break;
+
+          case "genepred":
+            this.decode = decodeGenePred;
+            this.delimiter = this.config.delimiter || /\s+/;
+            break;
+
+          case "genepredext":
+            this.decode = decodeGenePredExt;
+            this.delimiter = this.config.delimiter || /\s+/;
+            break;
+
+          case "ensgene":
+            this.decode = decodeGenePred;
+            this.header.shift = 1;
+            this.delimiter = this.config.delimiter || /\s+/;
+            break;
+
+          case "refgene":
+            this.decode = decodeGenePredExt;
+            this.delimiter = this.config.delimiter || /\s+/;
+            this.header.shift = 1;
+            break;
+
+          case "bed":
+            this.decode = decodeBed;
+            this.delimiter = this.config.delimiter || /\s+/;
+            break;
+
+          case "bedpe":
+            this.decode = decodeBedpe;
+            this.delimiter = this.config.delimiter || "\t";
+            break;
+
+          case "bedpe-domain":
+            this.decode = decodeBedpeDomain;
+            this.headerLine = true;
+            this.delimiter = this.config.delimiter || "\t";
+            break;
+
+          case "bedpe-loop":
+            this.decode = decodeBedpe;
+            this.delimiter = this.config.delimiter || "\t";
+            this.header = {
+              colorColumn: 7
+            };
+            break;
+
+          case "interact":
+            this.decode = decodeInteract;
+            this.delimiter = this.config.delimiter || /\s+/;
+            break;
+
+          case "snp":
+            this.decode = decodeSNP;
+            this.delimiter = "\t";
+            break;
+
+          case "rmsk":
+            this.decode = decodeRepeatMasker;
+            this.delimiter = "\t";
+            break;
+
+          case "gcnv":
+            this.decode = decodeGcnv;
+            this.delimiter = "\t";
+            break;
+
+          default:
+            const customFormat = getFormat(format);
+
+            if (customFormat !== undefined) {
+              this.decode = decodeCustom;
+              this.header.customFormat = customFormat;
+              this.delimiter = customFormat.delimiter || "\t";
+            } else {
+              this.decode = decodeBed;
+              this.delimiter = this.config.delimiter || /\s+/;
+            }
+
+        }
+      }
+
+    }
+
+    function parseTrackLine$1(line) {
+      const properties = {};
+      const tokens = line.split(/(?:")([^"]+)(?:")|([^\s"]+)(?=\s+|$)/g); // Clean up tokens array
+
+      let curr;
+      const tmp = [];
+
+      for (let tk of tokens) {
+        if (!tk || tk.trim().length === 0) continue;
+
+        if (tk.endsWith("=")) {
+          curr = tk;
+        } else if (curr) {
+          tmp.push(curr + tk);
+          curr = undefined;
+        } else {
+          tmp.push(tk);
+        }
+      }
+
+      for (let str of tmp) {
+        if (!str) return;
+        var kv = str.split('=', 2);
+
+        if (kv.length === 2) {
+          const key = kv[0].trim();
+          const value = kv[1].trim();
+
+          if (properties.hasOwnProperty(key)) {
+            let currentValue = properties[key];
+
+            if (Array.isArray(currentValue)) {
+              currentValue.push(value);
+            } else {
+              properties[key] = [currentValue, value];
+            }
+          } else {
+            properties[key] = value;
+          }
+        }
+      }
+
+      if ("interact" == properties["type"]) {
+        properties["format"] = "interact";
+      } else if ("gcnv" === properties["type"]) {
+        properties["format"] = "gcnv";
+      }
+
+      return properties;
+    }
+
+    function parseColumnsDirective$1(line) {
+      let properties = {};
+      let t1 = line.split(/\s+/);
+
+      if (t1.length === 2) {
+        let t2 = t1[1].split(";");
+        t2.forEach(function (keyValue) {
+          let t = keyValue.split("=");
+
+          if (t[0] === "color") {
+            properties.colorColumn = Number.parseInt(t[1]) - 1;
+          } else if (t[0] === "thickness") {
+            properties.thicknessColumn = Number.parseInt(t[1]) - 1;
+          }
+        });
+      }
+
+      return properties;
+    }
+
+    function parseFixedStep(line) {
+      const tokens = line.split(/\s+/);
+      const chrom = tokens[1].split("=")[1];
+      const start = parseInt(tokens[2].split("=")[1], 10) - 1;
+      const step = parseInt(tokens[3].split("=")[1], 10);
+      const span = tokens.length > 4 ? parseInt(tokens[4].split("=")[1], 10) : 1;
+      return {
+        format: "fixedStep",
+        chrom,
+        start,
+        step,
+        span,
+        index: 0
+      };
+    }
+
+    function parseVariableStep(line) {
+      const tokens = line.split(/\s+/);
+      const chrom = tokens[1].split("=")[1];
+      const span = tokens.length > 2 ? parseInt(tokens[2].split("=")[1], 10) : 1;
+      return {
+        format: "variableStep",
+        chrom,
+        span
+      };
+    }
+
+    /*
+     * The MIT License (MIT)
+     *
+     * Copyright (c) 2014 Broad Institute
+     *
+     * Permission is hereby granted, free of charge, to any person obtaining a copy
+     * of this software and associated documentation files (the "Software"), to deal
+     * in the Software without restriction, including without limitation the rights
+     * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+     * copies of the Software, and to permit persons to whom the Software is
+     * furnished to do so, subject to the following conditions:
+     *
+     * The above copyright notice and this permission notice shall be included in
+     * all copies or substantial portions of the Software.
+     *
+     *
+     * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+     * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+     * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+     * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+     * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+     * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+     * THE SOFTWARE.
+     */
+    /**
+     *  Define parser for seg files  (.bed, .gff, .vcf, etc).  A parser should implement 2 methods
+     *
+     *     parseHeader(data) - return an object representing a header.  Details are format specific
+     *
+     *     parseFeatures(data) - return a list of features
+     *
+     */
+
+    class SegParser {
+      constructor(type) {
+        this.type = type || 'seg'; // One of seg, mut, or maf
+
+        switch (this.type) {
+          case 'mut':
+            this.sampleColumn = 3;
+            this.chrColumn = 0;
+            this.startColumn = 1;
+            this.endColumn = 2;
+            this.dataColumn = 4;
+            break;
+
+          case 'maf':
+            this.sampleColumn = 15;
+            this.chrColumn = 4;
+            this.startColumn = 5;
+            this.endColumn = 6;
+            this.dataColumn = 8;
+            break;
+
+          default:
+            this.sampleColumn = 0;
+            this.chrColumn = 1;
+            this.startColumn = 2;
+            this.endColumn = 3;
+          // Data column determined after reading header
+        }
+      }
+
+      async parseHeader(dataWrapper) {
+        let line;
+
+        while ((line = await dataWrapper.nextLine()) !== undefined) {
+          if (line.startsWith("#")) ; else {
+            const tokens = line.split("\t");
+            this.header = {
+              headings: tokens
+            };
+            break;
+          }
+        }
+
+        return this.header;
+      }
+
+      async parseFeatures(dataWrapper) {
+        const allFeatures = [];
+        let extraHeaders;
+
+        if (!this.header) {
+          this.header = await this.parseHeader(dataWrapper); // This will only work for non-indexed files
+        }
+
+        if ('seg' === this.type) {
+          this.dataColumn = this.header.headings.length - 1;
+        }
+
+        if (this.header.headings.length > 5) {
+          extraHeaders = this.extractExtraColumns(this.header.headings);
+        }
+
+        const valueColumnName = this.header.headings[this.dataColumn];
+        let line;
+
+        while ((line = await dataWrapper.nextLine()) !== undefined) {
+          const tokens = line.split("\t");
+          const value = 'seg' === this.type ? parseFloat(tokens[this.dataColumn]) : tokens[this.dataColumn];
+
+          if (tokens.length > this.dataColumn) {
+            const feature = new SegFeature({
+              sample: tokens[this.sampleColumn],
+              chr: tokens[this.chrColumn],
+              start: parseInt(tokens[this.startColumn]) - 1,
+              end: parseInt(tokens[this.endColumn]),
+              value,
+              valueColumnName
+            });
+
+            if (extraHeaders) {
+              const extraValues = this.extractExtraColumns(tokens);
+              feature.setAttributes({
+                names: extraHeaders,
+                values: extraValues
+              });
+            }
+
+            allFeatures.push(feature);
+          }
+        }
+
+        return allFeatures;
+      }
+
+      extractExtraColumns(tokens) {
+        const extras = [];
+
+        for (let i = 0; i < tokens.length; i++) {
+          if (i !== this.chrColumn && i !== this.startColumn && i !== this.endColumn) {
+            extras.push(tokens[i]);
+          }
+        }
+
+        return extras;
+      }
+
+    }
+
+    class SegFeature {
+      constructor({
+        sample,
+        chr,
+        start,
+        end,
+        value,
+        valueColumnName
+      }) {
+        this.sample = sample;
+        this.chr = chr;
+        this.start = start;
+        this.end = end;
+        this.value = value;
+        this.valueColumnName = valueColumnName;
+      }
+
+      setAttributes({
+        names,
+        values
+      }) {
+        this.attributeNames = names;
+        this.attributeValues = values;
+      }
+
+      getAttribute(name) {
+        if (this.attributeNames) {
+          const idx = this.attributeNames.indexOf(name);
+
+          if (idx >= 0) {
+            return this.attributeValues[idx];
+          }
+        }
+
+        return undefined;
+      }
+
+      popupData() {
+        const locationString = this.chr + ":" + numberFormatter$1(this.start + 1) + "-" + numberFormatter$1(this.end);
+        const pd = [{
+          name: "Sample",
+          value: this.sample
+        }, {
+          name: "Location",
+          value: locationString
+        }, {
+          name: this.valueColumnName ? this.valueColumnName : "Value",
+          value: this.value
+        }];
+
+        if (this.attributeNames && this.attributeNames.length > 0) {
+          pd.push("<hr/>");
+
+          for (let i = 0; i < this.attributeNames.length; i++) {
+            pd.push({
+              name: this.attributeNames[i],
+              value: this.attributeValues[i]
+            });
+          }
+
+          pd.push("<hr/>"); // In case there are multiple features selected
+        }
+
+        return pd;
+      }
+
+    }
+
+    /*
+     * The MIT License (MIT)
+     *
+     * Copyright (c) 2018 Regents of the University of California
+     *
+     * Permission is hereby granted, free of charge, to any person obtaining a copy
+     * of this software and associated documentation files (the "Software"), to deal
+     * in the Software without restriction, including without limitation the rights
+     * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+     * copies of the Software, and to permit persons to whom the Software is
+     * furnished to do so, subject to the following conditions:
+     *
+     * The above copyright notice and this permission notice shall be included in
+     * all copies or substantial portions of the Software.
+     *
+     *
+     * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+     * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+     * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+     * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+     * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+     * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+     * THE SOFTWARE.
+     */
+    /**
+     * A collection of properties and methods shared by all (or most) track types.
+     *
+     * @param config
+     * @param browser
+     * @constructor
+     */
+
+    class TrackBase {
+      constructor(config, browser) {
+        this.browser = browser;
+        this.init(config);
+      }
+      /**
+       * Initialize track properties from the config object.  This method is typically overriden in subclasses, which
+       * will call this implementation as super.init(config).
+       *
+       * @param config
+       */
+
+
+      init(config) {
+        if (config.displayMode) {
+          config.displayMode = config.displayMode.toUpperCase();
+        }
+
+        this.config = config;
+        this.url = config.url;
+        this.type = config.type;
+        this.description = config.description;
+        this.supportHiDPI = config.supportHiDPI === undefined ? true : config.supportHiDPI;
+
+        if (config.name || config.label) {
+          this.name = config.name || config.label;
+        } else {
+          if (isFilePath(config.url)) this.name = config.url.name;else this.name = config.url;
+        }
+
+        this.id = this.config.id === undefined ? this.name : this.config.id;
+        this.order = config.order;
+        this.color = config.color;
+        this.altColor = config.altColor;
+
+        if ("civic-ws" === config.sourceType) {
+          // Ugly proxy for specialized track type
+          this.defaultColor = "rgb(155,20,20)";
+        } else {
+          this.defaultColor = "rgb(0,0,150)";
+        }
+
+        this.autoscaleGroup = config.autoscaleGroup;
+        this.removable = config.removable === undefined ? true : config.removable; // Defaults to true
+
+        this.height = config.height || 100;
+        this.autoHeight = config.autoHeight;
+        this.minHeight = config.minHeight || Math.min(25, this.height);
+        this.maxHeight = config.maxHeight || Math.max(1000, this.height);
+        this.visibilityWindow = config.visibilityWindow;
+        this.trackView = undefined;
+      }
+      /**
+       * Update track properties from the config object.
+       *
+       * @param config
+       */
+
+
+      updateConfig(config) {
+        this.init(config);
+      }
+      /**
+       * Default implementation -- update config with current values.
+       * to create session object for bookmarking, sharing.  Updates the track "config" object to reflect the
+       * current state.  Only simple properties (string, number, boolean) are updated.
+       */
+
+
+      getState() {
+        // Create copy of config, minus transient properties (convention is name starts with '_')
+        const state = {};
+
+        for (let key of Object.keys(this.config)) {
+          if (!key.startsWith("_")) {
+            state[key] = this.config[key];
+          }
+        } // Update original config values with any changes
+
+
+        for (let key of Object.keys(state)) {
+          if (key.startsWith("_")) continue; // transient property
+
+          const value = this[key];
+
+          if (value && (isSimpleType(value) || typeof value === "boolean")) {
+            state[key] = value;
+          }
+        }
+
+        if (this.color) state.color = this.color;
+        if (this.altColor) state.altColor = this.altColor; // Flatten dataRange if present
+
+        if (!this.autoscale && this.dataRange) {
+          state.min = this.dataRange.min;
+          state.max = this.dataRange.max;
+        } // Check for non-json-if-yable properties.  Perhaps we should test what can be saved.
+
+
+        for (let key of Object.keys(state)) {
+          if (typeof state[key] === 'function') {
+            throw Error(`Property '${key}' of track '${this.name} is a function. Functions cannot be saved in sessions.`);
+          }
+
+          if (state[key] instanceof File) {
+            const str = `Track ${this.name} is a local file. Sessions cannot be saved with local file references.`;
+            throw Error(str);
+          }
+
+          if (state[key] instanceof Promise) {
+            throw Error(`Property '${key}' of track '${this.name} is a Promise. Promises cannot be saved in sessions.`);
+          }
+        }
+
+        return state;
+      }
+
+      supportsWholeGenome() {
+        return false;
+      }
+      /**
+       * Does the track support sample names.  Current sample aware tracks include VCF (with genotypes), MUT, MAF, and SEG
+       * @returns {boolean}
+       */
+
+
+      hasSamples() {
+        return false;
+      }
+
+      getGenomeId() {
+        return this.browser.genome ? this.browser.genome.id : undefined;
+      }
+      /**
+       * Set certain track properties, usually from a "track" line.  Not all UCSC properties are supported.
+       *
+       * Track configuration settings have precendence over track line properties, so if both are present ignore the
+       * track line.
+       *
+       * @param properties
+       */
+
+
+      setTrackProperties(properties) {
+        const tracklineConfg = {};
+        let tokens;
+
+        for (let key of Object.keys(properties)) {
+          switch (key.toLowerCase()) {
+            case "usescore":
+              tracklineConfg.useScore = properties[key] === 1 || properties[key] === "1" || properties[key] === "on" || properties[key] === true;
+              break;
+
+            case "visibility":
+              //0 - hide, 1 - dense, 2 - full, 3 - pack, and 4 - squish
+              switch (properties[key]) {
+                case "2":
+                case "3":
+                case "pack":
+                case "full":
+                  tracklineConfg.displayMode = "EXPANDED";
+                  break;
+
+                case "4":
+                case "squish":
+                  tracklineConfg.displayMode = "SQUISHED";
+                  break;
+
+                case "1":
+                case "dense":
+                  tracklineConfg.displayMode = "COLLAPSED";
+              }
+
+              break;
+
+            case "color":
+            case "altcolor":
+              tracklineConfg[key] = properties[key].startsWith("rgb(") ? properties[key] : "rgb(" + properties[key] + ")";
+              break;
+
+            case "featurevisiblitywindow":
+            case "visibilitywindow":
+              tracklineConfg.visibilityWindow = Number.parseInt(properties[key]);
+              break;
+
+            case "maxheightpixels":
+              tokens = properties[key].split(":");
+
+              if (tokens.length === 3) {
+                tracklineConfg.minHeight = Number.parseInt(tokens[2]);
+                tracklineConfg.height = Number.parseInt(tokens[1]);
+                tracklineConfg.maxHeight = Number.parseInt(tokens[0]);
+              }
+
+              break;
+
+            case "viewlimits":
+              if (!this.config.autoscale) {
+                // autoscale in the config has precedence
+                tokens = properties[key].split(":");
+                let min = 0;
+                let max;
+
+                if (tokens.length == 1) {
+                  max = Number.parseFloat(tokens[0]);
+                } else if (tokens.length == 2) {
+                  min = Number.parseFloat(tokens[0]);
+                  max = Number.parseFloat(tokens[1]);
+                }
+
+                tracklineConfg.autoscale = false;
+                tracklineConfg.dataRange = {
+                  min,
+                  max
+                };
+              }
+
+            case "name":
+              tracklineConfg[key] = properties[key];
+              break;
+
+            case "url":
+              tracklineConfg["infoURL"] = properties[key];
+          }
+        } // Track configuration objects have precendence over track line properties
+
+
+        for (let key of Object.keys(tracklineConfg)) {
+          if (!this.config.hasOwnProperty(key)) {
+            this[key] = tracklineConfg[key];
+          }
+        }
+      }
+
+      getVisibilityWindow() {
+        return this.visibilityWindow;
+      }
+
+      clickedFeatures(clickState, features) {
+        // We use the cached features rather than method to avoid async load.  If the
+        // feature is not already loaded this won't work,  but the user wouldn't be mousing over it either.
+        if (!features) features = clickState.viewport.getCachedFeatures();
+
+        if (!features || features.length === 0) {
+          return [];
+        }
+
+        const genomicLocation = clickState.genomicLocation; // When zoomed out we need some tolerance around genomicLocation
+
+        const tolerance = clickState.referenceFrame.bpPerPixel > 0.2 ? 3 * clickState.referenceFrame.bpPerPixel : 0.2;
+        const ss = genomicLocation - tolerance;
+        const ee = genomicLocation + tolerance;
+        return FeatureUtils.findOverlapping(features, ss, ee);
+      }
+      /**
+       * Default popup text function -- just extracts string and number properties in random order.
+       * @param feature
+       * @returns {Array}
+       */
+
+
+      extractPopupData(feature, genomeId) {
+        const filteredProperties = new Set(['row', 'color', 'chr', 'start', 'end', 'cdStart', 'cdEnd', 'strand', 'alpha']);
+        const data = [];
+        let alleles, alleleFreqs;
+
+        for (var property in feature) {
+          if (feature.hasOwnProperty(property) && !filteredProperties.has(property) && isSimpleType(feature[property])) {
+            let value = feature[property];
+            data.push({
+              name: capitalize(property),
+              value: value
+            });
+
+            if (property === "alleles") {
+              alleles = feature[property];
+            } else if (property === "alleleFreqs") {
+              alleleFreqs = feature[property];
+            }
+          }
+        } //const genomeId = this.getGenomeId()
+
+
+        if (alleles && alleleFreqs) {
+          if (alleles.endsWith(",")) {
+            alleles = alleles.substr(0, alleles.length - 1);
+          }
+
+          if (alleleFreqs.endsWith(",")) {
+            alleleFreqs = alleleFreqs.substr(0, alleleFreqs.length - 1);
+          }
+
+          let a = alleles.split(",");
+          let af = alleleFreqs.split(",");
+
+          if (af.length > 1) {
+            let b = [];
+
+            for (let i = 0; i < af.length; i++) {
+              b.push({
+                a: a[i],
+                af: Number.parseFloat(af[i])
+              });
+            }
+
+            b.sort(function (x, y) {
+              return x.af - y.af;
+            });
+            let ref = b[b.length - 1].a;
+
+            if (ref.length === 1) {
+              for (let i = b.length - 2; i >= 0; i--) {
+                let alt = b[i].a;
+
+                if (alt.length === 1) {
+                  const cravatLink = TrackBase.getCravatLink(feature.chr, feature.start + 1, ref, alt, genomeId);
+
+                  if (cravatLink) {
+                    data.push("<hr/>");
+                    data.push({
+                      html: cravatLink
+                    });
+                    data.push("<hr/>");
+                  }
+                }
+              }
+            }
+          }
+        }
+
+        if (feature.attributes) {
+          for (let key of Object.keys(feature.attributes)) {
+            data.push({
+              name: key,
+              value: feature.attributes[key]
+            });
+          }
+        } // final chr position
+
+
+        let posString = `${feature.chr}:${numberFormatter$1(feature.start + 1)}-${numberFormatter$1(feature.end)}`;
+
+        if (feature.strand) {
+          posString += ` (${feature.strand})`;
+        }
+
+        data.push({
+          name: 'Location',
+          value: posString
+        });
+
+        if (this.infoURL) {
+          data.push("<hr/>");
+          const href = this.infoURL.replace("$$", feature.name);
+          data.push({
+            html: `<a target="_blank" href=${href}>${href}</a>`
+          });
+        }
+
+        return data;
+      }
+
+      static getCravatLink(chr, position, ref, alt, genomeID) {
+        if ("hg38" === genomeID || "GRCh38" === genomeID) {
+          const cravatChr = chr.startsWith("chr") ? chr : "chr" + chr;
+          return `<a target="_blank" href="https://run.opencravat.org/result/nocache/variant.html` + `?chrom=${cravatChr}&pos=${position}&ref_base=${ref}&alt_base=${alt}">Cravat ${ref}->${alt}</a>`; // return "<a target='_blank' " +
+          //     "href='https://www.cravat.us/CRAVAT/variant.html?variant=" +
+          //     cravatChr + "_" + position + "_+_" + ref + "_" + alt + "'>Cravat " + ref + "->" + alt + "</a>"
+        } else {
+          return undefined;
+        }
+      }
+
+    }
+
+    /*
+     * The MIT License (MIT)
+     *
+     * Copyright (c) 2014 Broad Institute
+     *
+     * Permission is hereby granted, free of charge, to any person obtaining a copy
+     * of this software and associated documentation files (the "Software"), to deal
+     * in the Software without restriction, including without limitation the rights
+     * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+     * copies of the Software, and to permit persons to whom the Software is
+     * furnished to do so, subject to the following conditions:
+     *
+     * The above copyright notice and this permission notice shall be included in
+     * all copies or substantial portions of the Software.
+     *
+     *
+     * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+     * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+     * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+     * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+     * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+     * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+     * THE SOFTWARE.
+     */
+    const knownAltBases = new Set(["A", "C", "T", "G"].map(c => c.charCodeAt(0)));
+
+    function createVCFVariant(tokens) {
+      return new Variant(tokens);
+    }
+
+    class Variant {
+      constructor(tokens) {
+        this.chr = tokens[0]; // TODO -- use genome aliases
+
+        this.pos = parseInt(tokens[1]);
+        this.names = tokens[2]; // id in VCF
+
+        this.referenceBases = tokens[3];
+        this.alternateBases = tokens[4];
+        this.quality = tokens[5];
+        this.filter = tokens[6];
+        this.info = getInfoObject(tokens[7]);
+        this.init();
+      }
+
+      init() {
+        const ref = this.referenceBases;
+        const altBases = this.alternateBases;
+
+        if (this.info) {
+          if (this.info["VT"]) {
+            this.type = this.info["VT"];
+          } else if (this.info["SVTYPE"]) {
+            this.type = "SV";
+          } else if (this.info["PERIOD"]) {
+            this.type = "STR";
+          }
+        }
+
+        if (this.type === undefined) {
+          this.type = determineType(ref, altBases);
+        }
+
+        if (this.type === "NONVARIANT") {
+          this.heterozygosity = 0;
+        } // Determine start/end coordinates -- these are the coordinates representing the actual variant,
+        // not the leading or trailing reference
+
+
+        if (this.info["END"]) {
+          this.start = this.pos - 1;
+
+          if (this.info["CHR2"] && this.info["CHR2"] !== this.chr) {
+            this.end = this.start + 1;
+          } else {
+            this.end = Number.parseInt(this.info["END"]);
+          }
+        } else {
+          if (this.type === "NONVARIANT") {
+            this.start = this.pos - 1; // convert to 0-based coordinate convention
+
+            this.end = this.start + ref.length;
+          } else {
+            const altTokens = altBases.split(",").filter(token => token.length > 0);
+            this.alleles = [];
+            this.start = undefined;
+            this.end = undefined;
+
+            for (let alt of altTokens) {
+              this.alleles.push(alt); // We don't yet handle  SV and other special alt representations
+
+              if ("SV" !== this.type && isKnownAlt(alt)) {
+                let altLength = alt.length;
+                let lengthOnRef = ref.length;
+                const lmin = Math.min(altLength, lengthOnRef); // Trim off matching bases.  Try first match, then right -> left,  then any remaining left -> right
+
+                let s = 0;
+
+                while (s < lmin && ref.charCodeAt(s) === alt.charCodeAt(s)) {
+                  s++;
+                  altLength--;
+                  lengthOnRef--;
+                } // right -> left from end
+
+
+                while (altLength > 0 && lengthOnRef > 0) {
+                  const altIdx = s + altLength - 1;
+                  const refIdx = s + lengthOnRef - 1;
+
+                  if (alt.charCodeAt(altIdx) === ref.charCodeAt(refIdx)) {
+                    altLength--;
+                    lengthOnRef--;
+                  } else {
+                    break;
+                  }
+                } // if any remaining, left -> right
+
+
+                while (altLength > 0 && lengthOnRef > 0) {
+                  const altIdx = s;
+                  const refIdx = s;
+
+                  if (alt.charCodeAt(altIdx) === ref.charCodeAt(refIdx)) {
+                    s++;
+                    altLength--;
+                    lengthOnRef--;
+                  } else {
+                    break;
+                  }
+                }
+
+                const alleleStart = this.pos + s - 1; // -1 for zero based coordinates
+
+                const alleleEnd = alleleStart + lengthOnRef;
+                this.start = this.start === undefined ? alleleStart : Math.min(this.start, alleleStart);
+                this.end = this.end === undefined ? alleleEnd : Math.max(this.end, alleleEnd);
+              }
+            } // Default to single base representation @ position for variant types not otherwise handled
+
+
+            if (this.start === undefined) {
+              this.start = this.pos - 1;
+              this.end = this.pos;
+            }
+          }
+        }
+      }
+
+      popupData(genomicLocation, genomeId) {
+        const posString = `${numberFormatter$1(this.pos)}`;
+        const locString = this.start === this.end ? `${numberFormatter$1(this.start)} | ${numberFormatter$1(this.start + 1)}` : `${numberFormatter$1(this.start + 1)}-${numberFormatter$1(this.end)}`;
+        const fields = [{
+          name: "Chr",
+          value: this.chr
+        }, {
+          name: "Pos",
+          value: posString
+        }, {
+          name: "Loc",
+          value: locString
+        }, {
+          name: "Names",
+          value: this.names ? this.names : ""
+        }, {
+          name: "Ref",
+          value: this.referenceBases
+        }, {
+          name: "Alt",
+          value: this.alternateBases.replace("<", "&lt;")
+        }, {
+          name: "Qual",
+          value: this.quality
+        }, {
+          name: "Filter",
+          value: this.filter
+        }];
+
+        if ("SNP" === this.type) {
+          let ref = this.referenceBases;
+
+          if (ref.length === 1) {
+            let altArray = this.alternateBases.split(",");
+
+            for (let alt of altArray) {
+              if (alt.length === 1) {
+                let l = TrackBase.getCravatLink(this.chr, this.pos, ref, alt, genomeId);
+
+                if (l) {
+                  fields.push("<hr/>");
+                  fields.push({
+                    html: l
+                  });
+                }
+              }
+            }
+          }
+        }
+
+        if (this.hasOwnProperty("heterozygosity")) {
+          fields.push({
+            name: "Heterozygosity",
+            value: this.heterozygosity
+          });
+        }
+
+        if (this.info) {
+          fields.push({
+            html: '<hr style="border-top: dotted 1px;border-color: #c9c3ba" />'
+          });
+
+          for (let key of Object.keys(this.info)) {
+            fields.push({
+              name: key,
+              value: arrayToString(decodeURIComponent(this.info[key]))
+            });
+          }
+        }
+
+        return fields;
+      }
+
+      isRefBlock() {
+        return "NONVARIANT" === this.type;
+      }
+
+    }
+
+    function getInfoObject(infoStr) {
+      var info = {};
+
+      if (infoStr) {
+        infoStr.split(';').forEach(function (elem) {
+          var element = elem.split('=');
+          info[element[0]] = element[1];
+        });
+      }
+
+      return info;
+    }
+
+    function isKnownAlt(alt) {
+      for (let i = 0; i < alt.length; i++) {
+        if (!knownAltBases.has(alt.charCodeAt(i))) {
+          return false;
+        }
+      }
+
+      return true;
+    }
+
+    function determineType(ref, altAlleles) {
+      const refLength = ref.length;
+
+      if (altAlleles === undefined) {
+        return "UNKNOWN";
+      } else if (altAlleles.trim().length === 0 || altAlleles === "<NON_REF>" || altAlleles === "<*>" || altAlleles === ".") {
+        return "NONVARIANT";
+      } else {
+        const alleles = altAlleles.split(",");
+        const types = alleles.map(function (a) {
+          if (refLength === 1 && a.length === 1) {
+            return "SNP";
+          } else {
+            return "<NON_REF>" === a ? "NONVARIANT" : "OTHER";
+          }
+        });
+        let type = types[0];
+
+        for (let t of types) {
+          if (t !== type) {
+            return "MIXED";
+          }
+        }
+
+        return type;
+      }
+    }
+
+    function arrayToString(value, delim) {
+      if (delim === undefined) delim = ",";
+
+      if (!Array.isArray(value)) {
+        return value;
+      }
+
+      return value.join(delim);
+    }
+    /**
+     * @deprecated - the GA4GH API has been deprecated.  This code no longer maintained.
+     * @param json
+     * @returns {Variant}
+     */
+
+
+    function createGAVariant(json) {
+      var variant = new Variant();
+      variant.chr = json.referenceName;
+      variant.start = parseInt(json.start); // Might get overriden below
+
+      variant.end = parseInt(json.end); // Might get overriden below
+
+      variant.pos = variant.start + 1; // GA4GH is 0 based.
+
+      variant.names = arrayToString(json.names, "; ");
+      variant.referenceBases = json.referenceBases;
+      variant.alternateBases = arrayToString(json.alternateBases);
+      variant.quality = json.quality;
+      variant.filter = arrayToString(json.filter); // Flatten GA4GH attributes array
+
+      variant.info = {};
+
+      if (json.info) {
+        Object.keys(json.info).forEach(function (key) {
+          var value,
+              valueArray = json.info[key];
+
+          if (Array.isArray(valueArray)) {
+            value = valueArray.join(",");
+          } else {
+            value = valueArray;
+          }
+
+          variant.info[key] = value;
+        });
+      } // Need to build a hash of calls for fast lookup
+      // Note from the GA4GH spec on call ID:
+      //
+      // The ID of the call set this variant call belongs to. If this field is not present,
+      // the ordering of the call sets from a SearchCallSetsRequest over this GAVariantSet
+      // is guaranteed to match the ordering of the calls on this GAVariant.
+      // The number of results will also be the same.
+
+
+      variant.calls = {};
+      var id;
+
+      if (json.calls) {
+        json.calls.forEach(function (call) {
+          id = call.callSetId;
+          variant.calls[id] = call;
+        });
+      }
+
+      init(variant);
+      return variant;
+    }
+
+    /*
+     * The MIT License (MIT)
+     *
+     * Copyright (c) 2014 Broad Institute
+     *
+     * Permission is hereby granted, free of charge, to any person obtaining a copy
+     * of this software and associated documentation files (the "Software"), to deal
+     * in the Software without restriction, including without limitation the rights
+     * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+     * copies of the Software, and to permit persons to whom the Software is
+     * furnished to do so, subject to the following conditions:
+     *
+     * The above copyright notice and this permission notice shall be included in
+     * all copies or substantial portions of the Software.
+     *
+     *
+     * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+     * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+     * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+     * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+     * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+     * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+     * THE SOFTWARE.
+     */
+    /**
+     * Parser for VCF files.
+     */
+
+    class VcfParser {
+      construtor() {}
+
+      async parseHeader(dataWrapper, genome) {
+        const header = {};
+        header.chrAliasTable = new Map(); // First line must be file format
+
+        let line = await dataWrapper.nextLine();
+
+        if (line.startsWith("##fileformat")) {
+          header.version = line.substr(13);
+        } else {
+          throw new Error("Invalid VCF file: missing fileformat line");
+        }
+
+        while ((line = await dataWrapper.nextLine()) !== undefined) {
+          if (line.startsWith("#")) {
+            let id;
+            const values = {};
+
+            if (line.startsWith("##")) {
+              if (line.startsWith("##INFO") || line.startsWith("##FILTER") || line.startsWith("##FORMAT")) {
+                const ltIdx = line.indexOf("<");
+                const gtIdx = line.lastIndexOf(">");
+
+                if (!(ltIdx > 2 && gtIdx > 0)) {
+                  continue;
+                }
+
+                const type = line.substring(2, ltIdx - 1);
+                if (!header[type]) header[type] = {}; //##INFO=<ID=AF,Number=A,Type=Float,Description="Allele frequency based on Flow Evaluator observation counts">
+                // ##FILTER=<ID=NOCALL,Description="Generic filter. Filtering details stored in FR info tag.">
+                // ##FORMAT=<ID=AF,Number=A,Type=Float,Description="Allele frequency based on Flow Evaluator observation counts">
+
+                const tokens = splitStringRespectingQuotes(line.substring(ltIdx + 1, gtIdx - 1), ",");
+
+                for (let token of tokens) {
+                  var kv = token.split("=");
+
+                  if (kv.length > 1) {
+                    if (kv[0] === "ID") {
+                      id = kv[1];
+                    } else {
+                      values[kv[0]] = kv[1];
+                    }
+                  }
+                }
+
+                if (id) {
+                  header[type][id] = values;
+                }
+              } else if (line.startsWith("##contig") && genome) {
+                const idx1 = line.indexOf("<ID=");
+                let idx2 = line.indexOf(",", idx1);
+
+                if (idx2 == -1) {
+                  idx2 = line.indexOf(">", idx1);
+                }
+
+                const chr = line.substring(idx1 + 4, idx2);
+                const canonicalChromosome = genome.getChromosomeName(chr);
+                header.chrAliasTable.set(canonicalChromosome, chr);
+              } else ;
+            } else if (line.startsWith("#CHROM")) {
+              const tokens = line.split("\t");
+
+              if (tokens.length > 8) {
+                // call set names -- use column index for id
+                header.callSets = [];
+
+                for (let j = 9; j < tokens.length; j++) {
+                  header.callSets.push({
+                    id: j,
+                    name: tokens[j]
+                  });
+                }
+              }
+            }
+          } else {
+            break;
+          }
+        }
+
+        this.header = header; // Will need to intrepret genotypes and info field
+
+        return header;
+      }
+      /**
+       * Parse data as a collection of Variant objects.
+       *
+       * @param data
+       * @returns {Array}
+       */
+
+
+      async parseFeatures(dataWrapper) {
+        const allFeatures = [];
+        const callSets = this.header.callSets;
+        const nExpectedColumns = 8 + (callSets ? callSets.length + 1 : 0);
+        let line;
+
+        while ((line = await dataWrapper.nextLine()) !== undefined) {
+          if (line && !line.startsWith("#")) {
+            const tokens = line.split("\t");
+
+            if (tokens.length === nExpectedColumns) {
+              const variant = createVCFVariant(tokens);
+              variant.header = this.header; // Keep a pointer to the header to interpret fields for popup text
+
+              allFeatures.push(variant);
+
+              if (tokens.length > 9) {
+                // Format
+                const callFields = extractCallFields(tokens[8].split(":"));
+                variant.calls = {};
+
+                for (let index = 9; index < tokens.length; index++) {
+                  const token = tokens[index];
+                  const callSet = callSets[index - 9];
+                  const call = {
+                    callSetName: callSet.name,
+                    info: {}
+                  };
+                  variant.calls[callSet.id] = call;
+                  token.split(":").forEach(function (callToken, idx) {
+                    switch (idx) {
+                      case callFields.genotypeIndex:
+                        call.genotype = [];
+                        callToken.split(/[\|\/]/).forEach(function (s) {
+                          call.genotype.push('.' === s ? s : parseInt(s));
+                        });
+                        break;
+
+                      default:
+                        call.info[callFields.fields[idx]] = callToken;
+                    }
+                  });
+                }
+              }
+            }
+          }
+        }
+
+        return allFeatures;
+      }
+
+    }
+
+    function extractCallFields(tokens) {
+      const callFields = {
+        genotypeIndex: -1,
+        fields: tokens
+      };
+
+      for (let i = 0; i < tokens.length; i++) {
+        if ("GT" === tokens[i]) {
+          callFields.genotypeIndex = i;
+        }
+      }
+
+      return callFields;
+    }
+
+    /*
+     * The MIT License (MIT)
+     *
+     * Copyright (c) 2016-2017 The Regents of the University of California
+     * Author: Jim Robinson
+     *
+     * Permission is hereby granted, free of charge, to any person obtaining a copy
+     * of this software and associated documentation files (the "Software"), to deal
+     * in the Software without restriction, including without limitation the rights
+     * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+     * copies of the Software, and to permit persons to whom the Software is
+     * furnished to do so, subject to the following conditions:
+     *
+     * The above copyright notice and this permission notice shall be included in
+     * all copies or substantial portions of the Software.
+     *
+     *
+     * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+     * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+     * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+     * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+     * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+     * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+     * THE SOFTWARE.
+     */
+    function getDataWrapper(data) {
+      if (typeof data == 'string' || data instanceof String) {
+        return new StringDataWrapper(data);
+      } else {
+        return new ByteArrayDataWrapper(data);
+      }
+    } // Data might be a string, or an UInt8Array
+
+
+    class StringDataWrapper {
+      constructor(string) {
+        this.data = string;
+        this.ptr = 0;
+      }
+
+      nextLine() {
+        var start = this.ptr,
+            idx = this.data.indexOf('\n', start),
+            data = this.data;
+
+        if (idx > 0) {
+          this.ptr = idx + 1; // Advance pointer for next line
+
+          if (idx > start && data.charAt(idx - 1) === '\r') {
+            // Trim CR manually in CR/LF sequence
+            return data.substring(start, idx - 1);
+          }
+
+          return data.substring(start, idx);
+        } else {
+          var length = data.length;
+          this.ptr = length; // Return undefined only at the very end of the data
+
+          return start >= length ? undefined : data.substring(start);
+        }
+      }
+
+    }
+
+    class ByteArrayDataWrapper {
+      constructor(array) {
+        this.data = array;
+        this.length = this.data.length;
+        this.ptr = 0;
+      }
+
+      nextLine() {
+        var c, result;
+        result = "";
+        if (this.ptr >= this.length) return undefined;
+
+        for (var i = this.ptr; i < this.length; i++) {
+          c = String.fromCharCode(this.data[i]);
+          if (c === '\r') continue;
+          if (c === '\n') break;
+          result = result + c;
+        }
+
+        this.ptr = i + 1;
+        return result;
+      }
+
+    }
+
+    /**
+     * Parser for IGV desktop GWAS files.  See http://software.broadinstitute.org/software/igv/GWAS
+     */
+
+    class GWASParser {
+      constructor(config) {
+        // Defaults - can be overriden by header
+        this.config = config;
+
+        if (config.columns) {
+          if (config.columns.chromosome === undefined || config.columns.position === undefined || config.columns.value === undefined) {
+            throw Error("columns property must define chrCol, posCol, and valueCol");
+          }
+
+          this.posCol = config.columns.position - 1;
+          this.chrCol = config.columns.chromosome - 1;
+          this.pvalueCol = config.columns.value - 1;
+        } else {
+          // Defaults -- can be overriden in header
+          this.posCol = 2;
+          this.chrCol = 1;
+          this.pvalueCol = 3;
+        }
+      }
+
+      async parseHeader(dataWrapper) {
+        const headerLine = await dataWrapper.nextLine();
+        return this.parseHeaderLine(headerLine);
+      }
+
+      parseHeaderLine(headerLine) {
+        this.columns = headerLine.split(/\t/);
+
+        if (!this.config.columns) {
+          for (let i = 0; i < this.columns.length; i++) {
+            const c = this.columns[i].toLowerCase();
+
+            switch (c) {
+              case 'chr':
+              case 'chromosome':
+              case 'chr_id':
+                this.chrCol = i;
+                break;
+
+              case 'bp':
+              case 'pos':
+              case 'position':
+              case 'chr_pos':
+                this.posCol = i;
+                break;
+
+              case 'p':
+              case 'pval':
+              case 'pvalue':
+              case 'p-value':
+              case 'p.value':
+                this.pvalueCol = i;
+                break;
+            }
+          }
+        }
+
+        return this.columns;
+      }
+
+      async parseFeatures(dataWrapper) {
+        const allFeatures = [];
+        const headerLine = dataWrapper.nextLine();
+
+        if (!this.columns) {
+          this.parseHeaderLine(headerLine);
+        }
+
+        let line;
+
+        while ((line = dataWrapper.nextLine()) !== undefined) {
+          const tokens = line.split(/\t/);
+
+          if (tokens.length === this.columns.length) {
+            const chr = tokens[this.chrCol];
+            const start = parseInt(tokens[this.posCol]) - 1;
+            const end = start + 1;
+            const value = parseFloat(tokens[this.pvalueCol]);
+            allFeatures.push(new GWASFeature({
+              chr: chr,
+              start: start,
+              end: end,
+              value: value,
+              line: line,
+              columns: this.columns
+            }));
+          }
+        }
+
+        return allFeatures;
+      }
+
+    }
+
+    class GWASFeature {
+      constructor({
+        chr,
+        start,
+        end,
+        value,
+        line,
+        columns
+      }) {
+        this.chr = chr;
+        this.start = start;
+        this.end = end;
+        this.value = value;
+        this.line = line;
+        this.columns = columns;
+      }
+
+      popupData() {
+        const tokens = this.line.split(/\t/);
+        return this.columns.map(function (c, index) {
+          return {
+            name: c,
+            value: tokens[index]
+          };
+        });
+      }
+
+      getAttribute(attrName) {
+        const tokens = this.line.split(/\t/);
+
+        for (let i = 0; i < this.columns.length; i++) {
+          if (this.columns[i] === attrName) {
+            return tokens[i];
+          }
+        }
+
+        return undefined;
+      }
+
+    }
+
+    /*
+     * The MIT License (MIT)
+     *
+     * Copyright (c) 2014 Broad Institute
+     *
+     * Permission is hereby granted, free of charge, to any person obtaining a copy
+     * of this software and associated documentation files (the "Software"), to deal
+     * in the Software without restriction, including without limitation the rights
+     * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+     * copies of the Software, and to permit persons to whom the Software is
+     * furnished to do so, subject to the following conditions:
+     *
+     * The above copyright notice and this permission notice shall be included in
+     * all copies or substantial portions of the Software.
+     *
+     *
+     * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+     * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+     * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+     * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+     * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+     * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+     * THE SOFTWARE.
+     */
+    /**
+     *  Define parsers for bed-like files  (.bed, .gff, .vcf, etc).  A parser should implement 2 methods
+     *
+     *     parseHeader(data) - return an object representing a header or metadata.  Details are format specific
+     *
+     *     parseFeatures(data) - return an array of features
+     *
+     */
+
+    var aedRegexpNoNamespace = new RegExp("([^:]*)\\(([^)]*)\\)"); // name(type) for AED parsing (namespace undefined)
+
+    var aedRegexpNamespace = new RegExp("([^:]*):([^(]*)\\(([^)]*)\\)"); // namespace:name(type) for AED parsing
+
+    class AEDParser {
+      constructor(config) {
+        const decode = config ? config.decode : undefined;
+        this.nameField = config ? config.nameField : undefined;
+        this.skipRows = 0; // The number of fixed header rows to skip.  Override for specific types as needed
+
+        if (decode) {
+          this.decode = decode;
+        } else {
+          this.decode = decodeAed;
+        }
+
+        this.delimiter = "\t";
+      }
+
+      async parseHeader(dataWrapper) {
+        let line;
+        let header;
+
+        while (line = await dataWrapper.nextLine()) {
+          if (line.startsWith("track") || line.startsWith("#") || line.startsWith("browser")) {
+            if (line.startsWith("track") || line.startsWith("#track")) {
+              let h = parseTrackLine(line);
+
+              if (header) {
+                Object.assign(header, h);
+              } else {
+                header = h;
+              }
+            } else if (line.startsWith("#columns")) {
+              let h = parseColumnsDirective(line);
+
+              if (header) {
+                Object.assign(header, h);
+              } else {
+                header = h;
+              }
+            } else if (line.startsWith("##gff-version 3")) {
+              this.format = "gff3";
+              if (!header) header = {};
+              header["format"] = "gff3";
+            }
+          } else {
+            break;
+          }
+        }
+
+        this.header = header; // Directives might be needed for parsing lines
+
+        return header;
+      }
+
+      async parseFeatures(dataWrapper) {
+        const allFeatures = [];
+        const decode = this.decode;
+        const delimiter = this.delimiter || "\t";
+        let i = 0;
+        let line;
+        let wig;
+
+        while ((line = dataWrapper.nextLine()) !== undefined) {
+          i++;
+
+          if (i <= this.skipRows || line.startsWith("track") || line.startsWith("#") || line.startsWith("browser")) {
+            continue;
+          }
+
+          let tokens = readTokensAed();
+
+          if (tokens.length < 1) {
+            continue;
+          }
+
+          if (!this.aed) {
+            // Store information about the aed header in the parser itself
+            // This is done only once - on the first row
+            this.aed = parseAedHeaderRow(tokens);
+            continue;
+          }
+
+          const feature = decode.call(this, tokens, wig);
+
+          if (feature) {
+            allFeatures.push(feature);
+          }
+        }
+
+        return allFeatures; // Double quoted strings can contain newlines in AED
+        // "" is an escape for a ".
+        // Parse all this, clean it up, split into tokens in a custom way
+
+        function readTokensAed() {
+          var tokens = [],
+              token = "",
+              quotedString = false,
+              n,
+              c;
+
+          while (line || line === '') {
+            for (n = 0; n < line.length; n++) {
+              c = line.charAt(n);
+
+              if (c === delimiter) {
+                if (!quotedString) {
+                  tokens.push(token);
+                  token = "";
+                } else {
+                  token += c;
+                }
+              } else if (c === "\"") {
+                // Look ahead to the next character
+                if (n + 1 < line.length && line.charAt(n + 1) === "\"") {
+                  if (quotedString) {
+                    // Turn "" into a single " in the output string
+                    token += "\"";
+                  } // Skip the next double quote
+
+
+                  n++;
+                } else {
+                  // We know the next character is NOT a double quote, flip our state
+                  quotedString = !quotedString;
+                }
+              } else {
+                token += c;
+              }
+            } // We are at the end of the line
+
+
+            if (quotedString) {
+              token += '\n'; // Add newline to the token
+
+              line = nextLine(); // Keep going
+            } else {
+              // We can end the loop
+              break;
+            }
+          } // Push the last token
+
+
+          tokens.push(token);
+          return tokens;
+        }
+      }
+
+    }
+
+    function parseAedToken(value) {
+      // Example: refseq:accessionNumber(aed:String)
+      // refseq - namespace, will be declared later
+      // accessionNumber - name of the field
+      // aed:String - type of the field
+      // The namespace part may be missing
+      var match = aedRegexpNamespace.exec(value);
+
+      if (match) {
+        return {
+          namespace: match[1],
+          name: match[2],
+          type: match[3]
+        };
+      }
+
+      match = aedRegexpNoNamespace.exec(value);
+
+      if (match) {
+        return {
+          namespace: '?',
+          name: match[1],
+          type: match[2]
+        };
+      } else {
+        throw new Error("Error parsing the header row of AED file - column not in ns:name(ns:type) format");
+      }
+    }
+
+    function parseAedHeaderRow(tokens) {
+      // First row of AED file defines column names
+      // Each header item is an aed token - see parseAedToken
+      var aed, k, token, aedToken; // Initialize aed section to be filled in
+
+      aed = {
+        columns: [// Information about the namespace, name and type of each column
+          // Example entry:
+          // { namespace: 'bio', name: 'start', type: 'aed:Integer' }
+        ],
+        metadata: {// Metadata about the entire AED file
+          // Example:
+          // {
+          //    aed: {
+          //       application: { value: "CHaS Browser 3.3.0.139 (r10838)", type: "aed:String" },
+          //       created: { value: "2018-01-02T10:20:30.123+01:00", type: "aed:DateTime" },
+          //       modified: { value: "2018-03-04T11:22:33.456+01:00", type: "aed:DateTime" },
+          //    }
+          //    affx: {
+          //       ucscGenomeVersion: { value: "hg19", type: "aed:String" }
+          //    },
+          //    namespace: {
+          //       omim: { value: "http://affymetrix.com/ontology/www.ncbi.nlm.nih.gov/omim/", type: "aed:URI" },
+          //       affx: { value: "http://affymetrix.com/ontology/", type: "aed:URI" },
+          //       refseq: { value: "http://affymetrix.com/ontology/www.ncbi.nlm.nih.gov/RefSeq/", type: "aed:URI" }
+          //    }
+          // }
+        }
+      };
+
+      for (k = 0; k < tokens.length; k++) {
+        token = tokens[k];
+        aedToken = parseAedToken(token);
+        aed.columns.push(aedToken);
+      }
+
+      return aed;
+    }
+
+    function parseTrackLine(line) {
+      const properties = {};
+      const tokens = line.split(/(?:")([^"]+)(?:")|([^\s"]+)(?=\s+|$)/g); // Clean up tokens array
+
+      let curr;
+      const tmp = [];
+
+      for (let tk of tokens) {
+        if (!tk || tk.trim().length === 0) continue;
+
+        if (tk.endsWith("=") > 0) {
+          curr = tk;
+        } else if (curr) {
+          tmp.push(curr + tk);
+          curr = undefined;
+        } else {
+          tmp.push(tk);
+        }
+      }
+
+      for (let str of tmp) {
+        if (!str) return;
+        var kv = str.split('=', 2);
+
+        if (kv.length === 2) {
+          const key = kv[0].trim();
+          const value = kv[1].trim();
+          properties[key] = value;
+        }
+      }
+
+      return properties;
+    }
+
+    function parseColumnsDirective(line) {
+      let properties = {};
+      let t1 = line.split(/\s+/);
+
+      if (t1.length === 2) {
+        let t2 = t1[1].split(";");
+        t2.forEach(function (keyValue) {
+          let t = keyValue.split("=");
+
+          if (t[0] === "color") {
+            properties.colorColumn = Number.parseInt(t[1]) - 1;
+          } else if (t[0] === "thickness") {
+            properties.thicknessColumn = Number.parseInt(t[1]) - 1;
+          }
+        });
+      }
+
+      return properties;
+    }
+    /**
+     * AED file feature.
+     *
+     * @param aed link to the AED file object containing file-level metadata and column descriptors
+     * @param allColumns All columns as parsed from the AED
+     *
+     * Other values are parsed one by one
+     */
+
+
+    function AedFeature(aed, allColumns) {
+      var token,
+          aedColumn,
+          aedColumns = aed.columns; // Link to AED file (for metadata)
+
+      this.aed = aed; // Unparsed columns from AED file
+
+      this.allColumns = allColumns; // Prepare space for the parsed values
+
+      this.chr = null;
+      this.start = null;
+      this.end = null;
+      this.score = 1000;
+      this.strand = '.';
+      this.cdStart = null;
+      this.cdEnd = null;
+      this.name = null;
+      this.color = null;
+
+      for (let i = 0; i < allColumns.length; i++) {
+        token = allColumns[i];
+
+        if (!token) {
+          // Skip empty fields
+          continue;
+        }
+
+        aedColumn = aedColumns[i];
+
+        if (aedColumn.type === 'aed:Integer') {
+          token = parseInt(token);
+        }
+
+        var arr = [];
+
+        if (aedColumn.namespace.length > 0) {
+          for (let j = 0; j < aedColumn.namespace.length; j++) {
+            arr.push(aedColumn.namespace.charCodeAt(j));
+          }
+        }
+
+        if (aedColumn.namespace.trim() === 'bio') {
+          if (aedColumn.name === 'sequence') {
+            this.chr = token;
+          } else if (aedColumn.name === 'start') {
+            this.start = token;
+          } else if (aedColumn.name === 'end') {
+            this.end = token;
+          } else if (aedColumn.name === 'cdsMin') {
+            this.cdStart = token;
+          } else if (aedColumn.name === 'cdsMax') {
+            this.cdEnd = token;
+          } else if (aedColumn.name === 'strand') {
+            this.strand = token;
+          }
+        } else if (aedColumn.namespace === 'aed') {
+          if (aedColumn.name === 'name') {
+            this.name = token;
+          }
+        } else if (aedColumn.namespace === 'style') {
+          if (aedColumn.name === 'color') {
+            this.color = IGVColor.createColorString(token);
+          }
+        }
+      }
+    }
+
+    AedFeature.prototype.popupData = function () {
+      var data = [],
+          aed = this.aed; // Just dump everything we have for now
+
+      for (var i = 0; i < this.allColumns.length; i++) {
+        var featureValue = this.allColumns[i];
+        var name = aed.columns[i].name; // Skip columns that are not interesting - you know the sequence, and you can see color
+
+        if (name !== 'sequence' && name !== 'color') {
+          if (featureValue) {
+            data.push({
+              name: name,
+              value: featureValue
+            });
+          }
+        }
+      }
+
+      return data;
+    };
+    /**
+     * Decode the AED file format
+     * @param tokens
+     * @param ignore
+     * @returns decoded feature, or null if this is not a valid record
+     */
+
+
+    function decodeAed(tokens, ignore) {
+      var name,
+          value,
+          token,
+          nonEmptyTokens = 0,
+          aedColumns = this.aed.columns,
+          aedColumn,
+          aedKey,
+          i; // Each aed row must match the exact number of columns or we skip it
+
+      if (tokens.length !== aedColumns.length) {
+        return undefined;
+      }
+
+      for (i = 0; i < tokens.length; i++) {
+        aedColumn = aedColumns[i];
+        token = tokens[i];
+
+        if (token !== '') {
+          nonEmptyTokens++;
+        }
+
+        if (aedColumn.name === 'name' && aedColumn.namespace === 'aed') {
+          name = token;
+        } else if (aedColumn.name === 'value' && aedColumn.namespace === 'aed') {
+          value = token;
+        }
+      }
+
+      if (nonEmptyTokens === 2 && name && value) {
+        // Special row that defines metadata for the entire file
+        aedKey = parseAedToken(name); // Store in the metadata section
+
+        if (!this.aed.metadata[aedKey.namespace]) {
+          this.aed.metadata[aedKey.namespace] = {};
+        }
+
+        if (!this.aed.metadata[aedKey.namespace][aedKey.name]) {
+          this.aed.metadata[aedKey.namespace][aedKey.name] = {
+            type: aedKey.type,
+            value: value
+          };
+        } // Ignore this value
+
+
+        return undefined;
+      }
+
+      var feature = new AedFeature(this.aed, tokens);
+
+      if (!feature.chr || !feature.start && feature.start !== 0 || !feature.end) {
+        return undefined;
+      }
+
+      return feature;
+    }
+
+    /*
+     * The MIT License (MIT)
+     *
+     * Copyright (c) 2014 Broad Institute
+     *
+     * Permission is hereby granted, free of charge, to any person obtaining a copy
+     * of this software and associated documentation files (the "Software"), to deal
+     * in the Software without restriction, including without limitation the rights
+     * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+     * copies of the Software, and to permit persons to whom the Software is
+     * furnished to do so, subject to the following conditions:
+     *
+     * The above copyright notice and this permission notice shall be included in
+     * all copies or substantial portions of the Software.
+     *
+     *
+     * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+     * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+     * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+     * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+     * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+     * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+     * THE SOFTWARE.
+     */
+    // TODO -- big endian?
+    class BinaryParser {
+      constructor(dataView, littleEndian) {
+        this.littleEndian = littleEndian !== undefined ? littleEndian : true;
+        this.position = 0;
+        this.view = dataView;
+        this.length = dataView.byteLength;
+      }
+
+      available() {
+        return this.length - this.position;
+      }
+
+      remLength() {
+        return this.length - this.position;
+      }
+
+      hasNext() {
+        return this.position < this.length - 1;
+      }
+
+      getByte() {
+        var retValue = this.view.getUint8(this.position, this.littleEndian);
+        this.position++;
+        return retValue;
+      }
+
+      getShort() {
+        var retValue = this.view.getInt16(this.position, this.littleEndian);
+        this.position += 2;
+        return retValue;
+      }
+
+      getUShort() {
+        // var byte1 = this.getByte(),
+        //     byte2 = this.getByte(),
+        //     retValue = ((byte2 << 24 >>> 16) + (byte1 << 24 >>> 24));
+        //     return retValue;
+        //
+        var retValue = this.view.getUint16(this.position, this.littleEndian);
+        this.position += 2;
+        return retValue;
+      }
+
+      getInt() {
+        var retValue = this.view.getInt32(this.position, this.littleEndian);
+        this.position += 4;
+        return retValue;
+      }
+
+      getUInt() {
+        var retValue = this.view.getUint32(this.position, this.littleEndian);
+        this.position += 4;
+        return retValue;
+      }
+
+      getLong() {
+        // DataView doesn't support long. So we'll try manually
+        var b = [];
+        b[0] = this.view.getUint8(this.position);
+        b[1] = this.view.getUint8(this.position + 1);
+        b[2] = this.view.getUint8(this.position + 2);
+        b[3] = this.view.getUint8(this.position + 3);
+        b[4] = this.view.getUint8(this.position + 4);
+        b[5] = this.view.getUint8(this.position + 5);
+        b[6] = this.view.getUint8(this.position + 6);
+        b[7] = this.view.getUint8(this.position + 7);
+        var value = 0;
+
+        if (this.littleEndian) {
+          for (let i = b.length - 1; i >= 0; i--) {
+            value = value * 256 + b[i];
+          }
+        } else {
+          for (let i = 0; i < b.length; i++) {
+            value = value * 256 + b[i];
+          }
+        }
+
+        this.position += 8;
+        return value;
+      }
+
+      getString(len) {
+        var s = "";
+        var c;
+
+        while ((c = this.view.getUint8(this.position++)) !== 0) {
+          s += String.fromCharCode(c);
+          if (len && s.length === len) break;
+        }
+
+        return s;
+      }
+
+      getFixedLengthString(len) {
+        var s = "";
+        var i;
+        var c;
+
+        for (i = 0; i < len; i++) {
+          c = this.view.getUint8(this.position++);
+
+          if (c > 0) {
+            s += String.fromCharCode(c);
+          }
+        }
+
+        return s;
+      }
+
+      getFixedLengthTrimmedString(len) {
+        var s = "";
+        var i;
+        var c;
+
+        for (i = 0; i < len; i++) {
+          c = this.view.getUint8(this.position++);
+
+          if (c > 32) {
+            s += String.fromCharCode(c);
+          }
+        }
+
+        return s;
+      }
+
+      getFloat() {
+        var retValue = this.view.getFloat32(this.position, this.littleEndian);
+        this.position += 4;
+        return retValue;
+      }
+
+      getDouble() {
+        var retValue = this.view.getFloat64(this.position, this.littleEndian);
+        this.position += 8;
+        return retValue;
+      }
+
+      skip(n) {
+        this.position += n;
+        return this.position;
+      }
+      /**
+       * Return a BGZip (bam and tabix) virtual pointer
+       * TODO -- why isn't 8th byte used ?
+       * @returns {*}
+       */
+
+
+      getVPointer() {
+        var position = this.position,
+            offset = this.view.getUint8(position + 1) << 8 | this.view.getUint8(position),
+            byte6 = (this.view.getUint8(position + 6) & 0xff) * 0x100000000,
+            byte5 = (this.view.getUint8(position + 5) & 0xff) * 0x1000000,
+            byte4 = (this.view.getUint8(position + 4) & 0xff) * 0x10000,
+            byte3 = (this.view.getUint8(position + 3) & 0xff) * 0x100,
+            byte2 = this.view.getUint8(position + 2) & 0xff,
+            block = byte6 + byte5 + byte4 + byte3 + byte2;
+        this.position += 8; //       if (block == 0 && offset == 0) {
+        //           return null;
+        //       } else {
+
+        return new VPointer(block, offset); //       }
+      }
+
+    }
+
+    class VPointer {
+      constructor(block, offset) {
+        this.block = block;
+        this.offset = offset;
+      }
+
+      isLessThan(vp) {
+        return this.block < vp.block || this.block === vp.block && this.offset < vp.offset;
+      }
+
+      isGreaterThan(vp) {
+        return this.block > vp.block || this.block === vp.block && this.offset > vp.offset;
+      }
+
+      print() {
+        return "" + this.block + ":" + this.offset;
+      }
+
+    }
+
+    const CSI1_MAGIC$1 = 21582659; // CSI\1
+
+    const CSI2_MAGIC$1 = 38359875; // CSI\2
+
+    async function parseCsiIndex(arrayBuffer, genome) {
+      const idx = new CSIIndex();
+      idx.parse(arrayBuffer, genome);
+      return idx;
+    }
+
+    class CSIIndex {
+      constructor(tabix) {
+        this.tabix = true; // Means whatever is indexed is BGZipped
+      }
+
+      parse(arrayBuffer, genome) {
+        const parser = new BinaryParser(new DataView(arrayBuffer));
+        const magic = parser.getInt();
+
+        if (magic !== CSI1_MAGIC$1) {
+          if (magic === CSI2_MAGIC$1) {
+            throw Error("CSI version 2 is not supported.  Please enter an issue at https://github.com/igvteam/igv.js");
+          } else {
+            throw Error("Not a CSI index");
+          }
+        }
+
+        this.indices = [];
+        this.blockMin = Number.MAX_SAFE_INTEGER;
+        this.blockMax = 0;
+        this.sequenceIndexMap = {};
+        this.minShift = parser.getInt();
+        this.depth = parser.getInt();
+        const lAux = parser.getInt();
+
+        if (lAux >= 28) {
+          // Tabix header parameters aren't used, but they must be read to advance the pointer
+          parser.getInt();
+          parser.getInt();
+          parser.getInt();
+          parser.getInt();
+          parser.getInt();
+          parser.getInt();
+          const l_nm = parser.getInt();
+          const nameEndPos = parser.position + l_nm;
+          let i = 0;
+
+          while (parser.position < nameEndPos) {
+            let seq_name = parser.getString(); // Translate to "official" chr name.
+
+            if (genome) {
+              seq_name = genome.getChromosomeName(seq_name);
+            }
+
+            this.sequenceIndexMap[seq_name] = i;
+            i++;
+          }
+        }
+
+        const MAX_BIN = this.bin_limit() + 1;
+        const nref = parser.getInt();
+
+        for (let ref = 0; ref < nref; ref++) {
+          const binIndex = [];
+          const loffset = [];
+          const nbin = parser.getInt();
+
+          for (let b = 0; b < nbin; b++) {
+            const binNumber = parser.getInt();
+            loffset[binNumber] = parser.getVPointer();
+
+            if (binNumber > MAX_BIN) {
+              // This is a psuedo bin, not used but we have to consume the bytes
+              parser.getInt(); // # of chunks for this bin
+
+              parser.getVPointer(); // unmapped beg
+
+              parser.getVPointer(); // unmapped end
+
+              parser.getLong();
+              parser.getLong();
+            } else {
+              binIndex[binNumber] = [];
+              const nchnk = parser.getInt(); // # of chunks for this bin
+
+              for (let i = 0; i < nchnk; i++) {
+                const cs = parser.getVPointer(); //chunk_beg
+
+                const ce = parser.getVPointer(); //chunk_end
+
+                if (cs && ce) {
+                  if (cs.block < this.blockMin) {
+                    this.blockMin = cs.block; // Block containing first alignment
+                  }
+
+                  if (ce.block > this.blockMax) {
+                    this.blockMax = ce.block;
+                  }
+
+                  binIndex[binNumber].push([cs, ce]);
+                }
+              }
+            }
+          }
+
+          if (nbin > 0) {
+            this.indices[ref] = {
+              binIndex: binIndex,
+              loffset: loffset
+            };
+          }
+        }
+      }
+      /**
+       * Fetch blocks for a particular genomic range.  This method is public so it can be unit-tested.
+       *
+       * @param refId  the sequence dictionary index of the chromosome
+       * @param min  genomic start position
+       * @param max  genomic end position
+       * @param return an array of {minv: {filePointer, offset}, {maxv: {filePointer, offset}}
+       */
+
+
+      blocksForRange(refId, min, max) {
+        const ba = this.indices[refId];
+
+        if (!ba) {
+          return [];
+        } else {
+          const overlappingBins = this.reg2bins(min, max); // List of bin #s that overlap min, max
+
+          if (overlappingBins.length == 0) return [];
+          const chunks = []; // Find chunks in overlapping bins.  Leaf bins (< 4681) are not pruned
+
+          for (let binRange of overlappingBins) {
+            for (let bin = binRange[0]; bin <= binRange[1]; bin++) {
+              if (ba.binIndex[bin]) {
+                const binChunks = ba.binIndex[bin];
+                const nchnk = binChunks.length;
+
+                for (let c = 0; c < nchnk; ++c) {
+                  const cs = binChunks[c][0];
+                  const ce = binChunks[c][1];
+                  chunks.push({
+                    minv: cs,
+                    maxv: ce,
+                    bin: bin
+                  });
+                }
+              }
+            }
+          }
+
+          const lowestOffset = ba.loffset[overlappingBins[0]];
+          return optimizeChunks$1(chunks, lowestOffset);
+        }
+      } // reg2bins implementation adapted from GMOD/tabix-js  https://github.com/GMOD/tabix-js/blob/master/src/csi.ts
+
+
+      reg2bins(beg, end) {
+        beg -= 1; // < convert to 1-based closed
+
+        if (beg < 1) beg = 1;
+        if (end > 2 ** 50) end = 2 ** 34; // 17 GiB ought to be enough for anybody
+
+        end -= 1;
+        let l = 0;
+        let t = 0;
+        let s = this.minShift + this.depth * 3;
+        const bins = [];
+
+        for (; l <= this.depth; s -= 3, t += 1 << l * 3, l += 1) {
+          const b = t + (beg >> s);
+          const e = t + (end >> s);
+          if (e - b + bins.length > this.maxBinNumber) throw new Error(`query ${beg}-${end} is too large for current binning scheme (shift ${this.minShift}, depth ${this.depth}), try a smaller query or a coarser index binning scheme`); //for (let i = b; i <= e; i += 1) bins.push(i)
+
+          bins.push([b, e]);
+        }
+
+        return bins;
+      } // function reg2bins(beg, end, min_shift, depth) {
+      //     let l, t, n, s = min_shift + depth * 3;
+      //     const bins = [];
+      //     for (--end, l = n = t = 0; l <= depth; s -= 3, t += 1 << l * 3, ++l) {
+      //         let b = t + (beg >> s), e = t + (end >> s), i;
+      //         for (i = b; i <= e; ++i) bins[n++] = i;
+      //     }
+      //     return bins;
+      // }
+
+
+      bin_limit() {
+        return ((1 << (this.depth + 1) * 3) - 1) / 7;
+      }
+
+    }
+
+    function optimizeChunks$1(chunks, lowest) {
+      const mergedChunks = [];
+      let lastChunk = null;
+      if (chunks.length === 0) return chunks;
+      chunks.sort(function (c0, c1) {
+        const dif = c0.minv.block - c1.minv.block;
+
+        if (dif !== 0) {
+          return dif;
+        } else {
+          return c0.minv.offset - c1.minv.offset;
+        }
+      });
+      chunks.forEach(function (chunk) {
+        if (!lowest || chunk.maxv.isGreaterThan(lowest)) {
+          if (lastChunk === null) {
+            mergedChunks.push(chunk);
+            lastChunk = chunk;
+          } else {
+            if (canMerge$1(lastChunk, chunk)) {
+              if (chunk.maxv.isGreaterThan(lastChunk.maxv)) {
+                lastChunk.maxv = chunk.maxv;
+              }
+            } else {
+              mergedChunks.push(chunk);
+              lastChunk = chunk;
+            }
+          }
+        }
+      });
+      return mergedChunks;
+    }
+
+    function canMerge$1(chunk1, chunk2) {
+      return chunk2.minv.block - chunk1.maxv.block < 65000 && chunk2.maxv.block - chunk1.minv.block < 5000000; // lastChunk.minv.block === lastChunk.maxv.block &&
+      // lastChunk.maxv.block === chunk.minv.block &&
+      // chunk.minv.block === chunk.maxv.block
+    }
+
+    const BAI_MAGIC$1 = 21578050;
+    const TABIX_MAGIC$1 = 21578324;
+
+    async function parseBamIndex(arrayBuffer, genome) {
+      return parseIndex(arrayBuffer, false, genome);
+    }
+
+    async function parseTabixIndex(arrayBuffer, genome) {
+      return parseIndex(arrayBuffer, true, genome);
+    }
+
+    async function parseIndex(arrayBuffer, tabix, genome) {
+      const indices = [];
+      let blockMin = Number.MAX_SAFE_INTEGER;
+      let blockMax = 0;
+      const parser = new BinaryParser(new DataView(arrayBuffer));
+      const magic = parser.getInt();
+      const sequenceIndexMap = {};
+
+      if (magic === BAI_MAGIC$1 || tabix && magic === TABIX_MAGIC$1) {
+        const nref = parser.getInt();
+
+        if (tabix) {
+          // Tabix header parameters aren't used, but they must be read to advance the pointer
+          parser.getInt();
+          parser.getInt();
+          parser.getInt();
+          parser.getInt();
+          parser.getInt();
+          parser.getInt();
+          parser.getInt();
+
+          for (let i = 0; i < nref; i++) {
+            let seq_name = parser.getString(); // Translate to "official" chr name.
+
+            if (genome) {
+              seq_name = genome.getChromosomeName(seq_name);
+            }
+
+            sequenceIndexMap[seq_name] = i;
+          }
+        }
+
+        for (let ref = 0; ref < nref; ref++) {
+          const binIndex = {};
+          const linearIndex = [];
+          const nbin = parser.getInt();
+
+          for (let b = 0; b < nbin; b++) {
+            const binNumber = parser.getInt();
+
+            if (binNumber === 37450) {
+              // This is a psuedo bin, not used but we have to consume the bytes
+              parser.getInt(); // # of chunks for this bin
+
+              parser.getVPointer(); // unmapped beg
+
+              parser.getVPointer(); // unmapped end
+
+              parser.getLong();
+              parser.getLong();
+            } else {
+              binIndex[binNumber] = [];
+              const nchnk = parser.getInt(); // # of chunks for this bin
+
+              for (let i = 0; i < nchnk; i++) {
+                const cs = parser.getVPointer(); //chunk_beg
+
+                const ce = parser.getVPointer(); //chunk_end
+
+                if (cs && ce) {
+                  if (cs.block < blockMin) {
+                    blockMin = cs.block; // Block containing first alignment
+                  }
+
+                  if (ce.block > blockMax) {
+                    blockMax = ce.block;
+                  }
+
+                  binIndex[binNumber].push([cs, ce]);
+                }
+              }
+            }
+          }
+
+          const nintv = parser.getInt();
+
+          for (let i = 0; i < nintv; i++) {
+            const cs = parser.getVPointer();
+            linearIndex.push(cs); // Might be null
+          }
+
+          if (nbin > 0) {
+            indices[ref] = {
+              binIndex: binIndex,
+              linearIndex: linearIndex
+            };
+          }
+        }
+      } else {
+        throw new Error(indexURL + " is not a " + (tabix ? "tabix" : "bai") + " file");
+      }
+
+      return new BamIndex(indices, blockMin, blockMax, sequenceIndexMap, tabix);
+    }
+
+    class BamIndex {
+      constructor(indices, blockMin, blockMax, sequenceIndexMap, tabix) {
+        this.firstAlignmentBlock = blockMin;
+        this.lastAlignmentBlock = blockMax;
+        this.indices = indices;
+        this.sequenceIndexMap = sequenceIndexMap;
+        this.tabix = tabix;
+      }
+      /**
+       * Fetch blocks for a particular genomic range.  This method is public so it can be unit-tested.
+       *
+       * @param refId  the sequence dictionary index of the chromosome
+       * @param min  genomic start position
+       * @param max  genomic end position
+       * @param return an array of {minv: {filePointer, offset}, {maxv: {filePointer, offset}}
+       */
+
+
+      blocksForRange(refId, min, max) {
+        const bam = this;
+        const ba = bam.indices[refId];
+
+        if (!ba) {
+          return [];
+        } else {
+          const overlappingBins = reg2bins(min, max); // List of bin #s that overlap min, max
+
+          const chunks = []; // Find chunks in overlapping bins.  Leaf bins (< 4681) are not pruned
+
+          for (let binRange of overlappingBins) {
+            for (let bin = binRange[0]; bin <= binRange[1]; bin++) {
+              if (ba.binIndex[bin]) {
+                const binChunks = ba.binIndex[bin],
+                      nchnk = binChunks.length;
+
+                for (let c = 0; c < nchnk; ++c) {
+                  const cs = binChunks[c][0];
+                  const ce = binChunks[c][1];
+                  chunks.push({
+                    minv: cs,
+                    maxv: ce,
+                    bin: bin
+                  });
+                }
+              }
+            }
+          } // Use the linear index to find minimum file position of chunks that could contain alignments in the region
+
+
+          const nintv = ba.linearIndex.length;
+          let lowest = null;
+          const minLin = Math.min(min >> 14, nintv - 1);
+          const maxLin = Math.min(max >> 14, nintv - 1);
+
+          for (let i = minLin; i <= maxLin; ++i) {
+            const vp = ba.linearIndex[i];
+
+            if (vp) {
+              // todo -- I think, but am not sure, that the values in the linear index have to be in increasing order.  So the first non-null should be minimum
+              if (!lowest || vp.isLessThan(lowest)) {
+                lowest = vp;
+              }
+            }
+          }
+
+          return optimizeChunks(chunks, lowest);
+        }
+      }
+
+    }
+
+    function optimizeChunks(chunks, lowest) {
+      const mergedChunks = [];
+      let lastChunk = null;
+      if (chunks.length === 0) return chunks;
+      chunks.sort(function (c0, c1) {
+        const dif = c0.minv.block - c1.minv.block;
+
+        if (dif !== 0) {
+          return dif;
+        } else {
+          return c0.minv.offset - c1.minv.offset;
+        }
+      });
+      chunks.forEach(function (chunk) {
+        if (!lowest || chunk.maxv.isGreaterThan(lowest)) {
+          if (lastChunk === null) {
+            mergedChunks.push(chunk);
+            lastChunk = chunk;
+          } else {
+            if (canMerge(lastChunk, chunk)) {
+              if (chunk.maxv.isGreaterThan(lastChunk.maxv)) {
+                lastChunk.maxv = chunk.maxv;
+              }
+            } else {
+              mergedChunks.push(chunk);
+              lastChunk = chunk;
+            }
+          }
+        }
+      });
+      return mergedChunks;
+    }
+
+    function canMerge(chunk1, chunk2) {
+      return chunk2.minv.block - chunk1.maxv.block < 65000 && chunk2.maxv.block - chunk1.minv.block < 5000000; // lastChunk.minv.block === lastChunk.maxv.block &&
+      // lastChunk.maxv.block === chunk.minv.block &&
+      // chunk.minv.block === chunk.maxv.block
+    }
+    /**
+     * Calculate the list of bins that overlap with region [beg, end]
+     *
+     */
+
+
+    function reg2bins(beg, end) {
+      const list = [];
+      if (end >= 1 << 29) end = 1 << 29;
+      --end;
+      list.push([0, 0]);
+      list.push([1 + (beg >> 26), 1 + (end >> 26)]);
+      list.push([9 + (beg >> 23), 9 + (end >> 23)]);
+      list.push([73 + (beg >> 20), 73 + (end >> 20)]);
+      list.push([585 + (beg >> 17), 585 + (end >> 17)]);
+      list.push([4681 + (beg >> 14), 4681 + (end >> 14)]); // for (k = 1 + (beg >> 26); k <= 1 + (end >> 26); ++k) list.push(k);
+      // for (k = 9 + (beg >> 23); k <= 9 + (end >> 23); ++k) list.push(k);
+      // for (k = 73 + (beg >> 20); k <= 73 + (end >> 20); ++k) list.push(k);
+      // for (k = 585 + (beg >> 17); k <= 585 + (end >> 17); ++k) list.push(k);
+      // for (k = 4681 + (beg >> 14); k <= 4681 + (end >> 14); ++k) list.push(k);
+
+      return list;
+    }
+
+    /*
+     * The MIT License (MIT)
+     *
+     * Copyright (c) 2014 Broad Institute
+     *
+     * Permission is hereby granted, free of charge, to any person obtaining a copy
+     * of this software and associated documentation files (the "Software"), to deal
+     * in the Software without restriction, including without limitation the rights
+     * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+     * copies of the Software, and to permit persons to whom the Software is
+     * furnished to do so, subject to the following conditions:
+     *
+     * The above copyright notice and this permission notice shall be included in
+     * all copies or substantial portions of the Software.
+     *
+     *
+     * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+     * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+     * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+     * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+     * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+     * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+     * THE SOFTWARE.
+     */
+
+    async function parseTribbleIndex(arrayBuffer, genome) {
+      const index = {};
+      const parser = new BinaryParser(new DataView(arrayBuffer));
+      readHeader(parser);
+      let nChrs = parser.getInt();
+
+      while (nChrs-- > 0) {
+        // todo -- support interval tree index, we're assuming its a linear index
+        const chrIdx = readLinear(parser);
+        index[chrIdx.chr] = chrIdx;
+      }
+
+      return new TribbleIndex(index);
+      /**
+       * Read the header file.   Data here is not used in igv.js but we need to read it to advance the pointer.
+       * @param parser
+       */
+
+      function readHeader(parser) {
+        parser.getInt(); //   view._getInt32(offset += 32, true);
+
+        parser.getInt();
+        const version = parser.getInt();
+        parser.getString();
+        parser.getLong();
+        parser.getLong();
+        parser.getString();
+        parser.getInt();
+
+        if (version >= 3) {
+          let nProperties = parser.getInt();
+
+          while (nProperties-- > 0) {
+            parser.getString();
+            parser.getString();
+          }
+        }
+      }
+
+      function readLinear(parser) {
+        let chr = parser.getString();
+
+        if (genome) chr = genome.getChromosomeName(chr);
+        const binWidth = parser.getInt();
+        const nBins = parser.getInt();
+        const longestFeature = parser.getInt();
+        parser.getInt() > 0;
+        parser.getInt(); // note the code below accounts for > 60% of the total time to read an index
+
+        let pos = parser.getLong();
+        const blocks = new Array();
+
+        for (let binNumber = 0; binNumber < nBins; binNumber++) {
+          const nextPos = parser.getLong();
+          blocks.push({
+            min: pos,
+            max: nextPos
+          }); //        {position: pos, size: size});
+
+          pos = nextPos;
+        }
+
+        return {
+          chr: chr,
+          blocks: blocks,
+          longestFeature: longestFeature,
+          binWidth: binWidth
+        };
+      }
+    }
+
+    class TribbleIndex {
+      constructor(chrIndexTable) {
+        this.chrIndex = chrIndexTable; // Dictionary of chr -> tribble index
+      }
+      /**
+       * Fetch blocks for a particular genomic range.
+       *
+       * @param queryChr the sequence dictionary index of the chromosome
+       * @param min  genomic start position
+       * @param max  genomic end position
+       */
+
+
+      blocksForRange(queryChr, min, max) {
+        const chrIdx = this.chrIndex[queryChr];
+
+        if (chrIdx) {
+          const blocks = chrIdx.blocks;
+          const longestFeature = chrIdx.longestFeature;
+          const binWidth = chrIdx.binWidth;
+          const adjustedPosition = Math.max(min - longestFeature, 0);
+          const startBinNumber = Math.floor(adjustedPosition / binWidth);
+          if (startBinNumber >= blocks.length) // are we off the end of the bin list, so return nothing
+            return [];else {
+            const endBinNumber = Math.min(Math.floor((max - 1) / binWidth), blocks.length - 1); // By definition blocks are adjacent in the file for the liner index.  Combine them into one merged block
+
+            const startPos = blocks[startBinNumber].min;
+            const endPos = blocks[endBinNumber].max;
+            const size = endPos - startPos;
+
+            if (size === 0) {
+              return [];
+            } else {
+              const mergedBlock = {
+                minv: {
+                  block: startPos,
+                  offset: 0
+                },
+                maxv: {
+                  block: endPos,
+                  offset: 0
+                }
+              };
+              return [mergedBlock];
+            }
+          }
+        } else {
+          return undefined;
+        }
+      }
+
+    }
+
+    const CSI1_MAGIC = 21582659; // CSI\1
+
+    const CSI2_MAGIC = 38359875; // CSI\2
+
+    const BAI_MAGIC = 21578050;
+    const TABIX_MAGIC = 21578324;
+    const TRIBBLE_MAGIC = 1480870228; //  byte[]{'T', 'I', 'D', 'X'};
+
+    /**
+     * @param indexURL
+     * @param config
+     * @param tabix
+     *
+     */
+
+    async function loadIndex(indexURL, config, genome) {
+      let arrayBuffer = await igvxhr.loadArrayBuffer(indexURL, buildOptions(config));
+      let dv = new DataView(arrayBuffer); // Some indexs are gzipped, specifically tabix, and csi.  Bam (bai) are not.  Tribble is usually not.
+      // Check first 2 bytes of file for gzip magic number, and inflate if neccessary
+
+      if (dv.getUint8(0) === 0x1f && dv.getUint8(1) === 0x8b) {
+        // gzipped
+        const inflate = new Zlib$1.Gunzip(new Uint8Array(arrayBuffer));
+        arrayBuffer = inflate.decompress().buffer;
+        dv = new DataView(arrayBuffer);
+      }
+
+      const magic = dv.getInt32(0, true);
+
+      switch (magic) {
+        case BAI_MAGIC:
+          return parseBamIndex(arrayBuffer, genome);
+
+        case TABIX_MAGIC:
+          return parseTabixIndex(arrayBuffer, genome);
+
+        case CSI1_MAGIC:
+          return parseCsiIndex(arrayBuffer, genome);
+
+        case TRIBBLE_MAGIC:
+          return parseTribbleIndex(arrayBuffer, genome);
+
+        case CSI2_MAGIC:
+          throw Error("CSI version 2 is not supported.");
+
+        default:
+          throw Error(`Unrecognized index type: ${indexURL}`);
+      }
+    }
+
+    class BGZipLineReader {
+      constructor(config) {
+        this.config = config;
+        this.filePtr = 0;
+        this.bufferPtr = 0;
+        this.buffer;
+      }
+
+      async nextLine() {
+        let result = undefined;
+
+        try {
+          while (true) {
+            const length = this.buffer ? this.buffer.length : 0;
+
+            while (this.bufferPtr < length) {
+              const c = String.fromCharCode(this.buffer[this.bufferPtr++]);
+              if (c === '\r') continue;
+
+              if (c === '\n') {
+                return result;
+              }
+
+              result = result ? result + c : c;
+            }
+
+            if (this.eof) {
+              return result;
+            } else {
+              await this.readNextBlock();
+            }
+          }
+        } catch (e) {
+          console.warn(e);
+          this.eof = true;
+          return result;
+        }
+      }
+
+      async readNextBlock() {
+        const bsizeOptions = buildOptions(this.config, {
+          range: {
+            start: this.filePtr,
+            size: 26
+          }
+        });
+        const abuffer = await igvxhr.loadArrayBuffer(this.config.url, bsizeOptions);
+        const bufferSize = bgzBlockSize(abuffer); //console.log(`next block ${this.filePtr}  ${bufferSize}`);
+
+        if (bufferSize === 0) {
+          this.eof = true;
+          this.buffer = undefined;
+        } else {
+          const options = buildOptions(this.config, {
+            range: {
+              start: this.filePtr,
+              size: bufferSize
+            }
+          });
+          const data = await igvxhr.loadArrayBuffer(this.config.url, options);
+
+          if (data.byteLength < bufferSize) {
+            this.eof = true; // Assumption
+          }
+
+          this.buffer = unbgzf(data);
+          this.bufferPtr = 0;
+          this.filePtr += data.byteLength; //data.byteLength;
+        }
+      }
+
+    }
+
+    /*
+     * The MIT License (MIT)
+     *
+     * Copyright (c) 2014 Broad Institute
+     *
+     * Permission is hereby granted, free of charge, to any person obtaining a copy
+     * of this software and associated documentation files (the "Software"), to deal
+     * in the Software without restriction, including without limitation the rights
+     * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+     * copies of the Software, and to permit persons to whom the Software is
+     * furnished to do so, subject to the following conditions:
+     *
+     * The above copyright notice and this permission notice shall be included in
+     * all copies or substantial portions of the Software.
+     *
+     *
+     * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+     * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+     * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+     * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+     * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+     * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+     * THE SOFTWARE.
+     */
+    const isString$5 = isString$6;
+    /**
+     * Reader for "bed like" files (tab delimited files with 1 feature per line: bed, gff, vcf, etc)
+     *
+     * @param config
+     * @constructor
+     */
+
+    class FeatureFileReader {
+      constructor(config, genome) {
+        var uriParts;
+        this.config = config || {};
+        this.genome = genome;
+        this.indexURL = config.indexURL;
+        this.indexed = config.indexed;
+
+        if (isFilePath(this.config.url)) {
+          this.filename = this.config.url.name;
+        } else if (isString$5(this.config.url) && this.config.url.startsWith('data:')) {
+          this.indexed = false; // by definition
+
+          this.dataURI = config.url;
+        } else {
+          uriParts = parseUri(this.config.url);
+          this.filename = config.filename || uriParts.file;
+        }
+
+        this.parser = this.getParser(this.config);
+
+        if (this.config.format === "vcf" && !this.config.indexURL) {
+          console.warn("Warning: index file not specified.  The entire vcf file will be loaded.");
+        }
+      }
+      /**
+       * Return a promise to load features for the genomic interval
+       * @param chr
+       * @param start
+       * @param end
+       */
+
+
+      async readFeatures(chr, start, end) {
+        const index = await this.getIndex();
+
+        if (index) {
+          this.indexed = true;
+          return this.loadFeaturesWithIndex(chr, start, end);
+        } else if (this.dataURI) {
+          this.indexed = false;
+          return this.loadFeaturesFromDataURI();
+        } else {
+          this.indexed = false;
+          return this.loadFeaturesNoIndex();
+        }
+      }
+
+      async readHeader() {
+        if (this.dataURI) {
+          await this.loadFeaturesFromDataURI(this.dataURI);
+          return this.header;
+        } else {
+          if (this.config.indexURL) {
+            const index = await this.getIndex();
+
+            if (!index) {
+              // Note - it should be impossible to get here
+              throw new Error("Unable to load index: " + this.config.indexURL);
+            }
+
+            let dataWrapper;
+
+            if (index.tabix) {
+              dataWrapper = new BGZipLineReader(this.config);
+            } else {
+              // Tribble
+              const maxSize = Object.values(index.chrIndex).flatMap(chr => chr.blocks).map(block => block.max).reduce((previous, current) => Math.min(previous, current), Number.MAX_SAFE_INTEGER);
+              const options = buildOptions(this.config, {
+                bgz: index.tabix,
+                range: {
+                  start: 0,
+                  size: maxSize
+                }
+              });
+              const data = await igvxhr.loadString(this.config.url, options);
+              dataWrapper = getDataWrapper(data);
+            }
+
+            this.header = await this.parser.parseHeader(dataWrapper); // Cache header, might be needed to parse features
+
+            return this.header;
+          } else {
+            // If this is a non-indexed file we will load all features in advance
+            const options = buildOptions(this.config);
+            const data = await igvxhr.loadString(this.config.url, options);
+            let dataWrapper = getDataWrapper(data);
+            this.header = await this.parser.parseHeader(dataWrapper); // Reset data wrapper and parse features
+
+            dataWrapper = getDataWrapper(data);
+            this.features = await this.parser.parseFeatures(dataWrapper); // cache features
+
+            return this.header;
+          }
+        }
+      }
+
+      getParser(config) {
+        switch (config.format) {
+          case "vcf":
+            return new VcfParser(config);
+
+          case "seg":
+            return new SegParser("seg");
+
+          case "mut":
+            return new SegParser("mut");
+
+          case "maf":
+            return new SegParser("maf");
+
+          case "gwas":
+            return new GWASParser(config);
+
+          case "aed":
+            return new AEDParser(config);
+
+          default:
+            return new FeatureParser(config);
+        }
+      }
+
+      async loadFeaturesNoIndex() {
+        if (this.features) {
+          // An optimization hack for non-indexed files, features are temporarily cached when header is read.
+          const tmp = this.features;
+          delete this.features;
+          return tmp;
+        } else {
+          const options = buildOptions(this.config); // Add oauth token, if any
+
+          const data = await igvxhr.loadString(this.config.url, options);
+
+          if (!this.header) {
+            const dataWrapper = getDataWrapper(data);
+            this.header = await this.parser.parseHeader(dataWrapper);
+          }
+
+          const dataWrapper = getDataWrapper(data);
+          const features = await this.parser.parseFeatures(dataWrapper); // <= PARSING DONE HERE
+
+          return features;
+        }
+      }
+
+      async loadFeaturesWithIndex(chr, start, end) {
+        //console.log("Using index"
+        const config = this.config;
+        const parser = this.parser;
+        const tabix = this.index.tabix;
+        const refId = tabix ? this.index.sequenceIndexMap[chr] : chr;
+
+        if (refId === undefined) {
+          return [];
+        }
+
+        const genome = this.genome;
+        const blocks = this.index.blocksForRange(refId, start, end);
+
+        if (!blocks || blocks.length === 0) {
+          return [];
+        } else {
+          const allFeatures = [];
+
+          for (let block of blocks) {
+            const startPos = block.minv.block;
+            const startOffset = block.minv.offset;
+            const endOffset = block.maxv.offset;
+            let endPos;
+
+            if (tabix) {
+              let lastBlockSize = 0;
+
+              if (endOffset > 0) {
+                const bsizeOptions = buildOptions(config, {
+                  range: {
+                    start: block.maxv.block,
+                    size: 26
+                  }
+                });
+                const abuffer = await igvxhr.loadArrayBuffer(config.url, bsizeOptions);
+                lastBlockSize = bgzBlockSize(abuffer);
+              }
+
+              endPos = block.maxv.block + lastBlockSize;
+            } else {
+              endPos = block.maxv.block;
+            }
+
+            const options = buildOptions(config, {
+              range: {
+                start: startPos,
+                size: endPos - startPos + 1
+              }
+            });
+            let inflated;
+
+            if (tabix) {
+              const data = await igvxhr.loadArrayBuffer(config.url, options);
+              inflated = unbgzf(data);
+            } else {
+              inflated = await igvxhr.loadString(config.url, options);
+            }
+
+            const slicedData = startOffset ? inflated.slice(startOffset) : inflated;
+            const dataWrapper = getDataWrapper(slicedData);
+            const slicedFeatures = await parser.parseFeatures(dataWrapper); // Filter features not in requested range.
+
+            let inInterval = false;
+
+            for (let i = 0; i < slicedFeatures.length; i++) {
+              const f = slicedFeatures[i];
+              const canonicalChromosome = genome ? genome.getChromosomeName(f.chr) : f.chr;
+
+              if (canonicalChromosome !== chr) {
+                if (allFeatures.length === 0) {
+                  continue; //adjacent chr to the left
+                } else {
+                  break; //adjacent chr to the right
+                }
+              }
+
+              if (f.start > end) {
+                allFeatures.push(f); // First feature beyond interval
+
+                break;
+              }
+
+              if (f.end >= start && f.start <= end) {
+                if (!inInterval) {
+                  inInterval = true;
+
+                  if (i > 0) {
+                    allFeatures.push(slicedFeatures[i - 1]);
+                  }
+                }
+
+                allFeatures.push(f);
+              }
+            }
+          }
+
+          allFeatures.sort(function (a, b) {
+            return a.start - b.start;
+          });
+          return allFeatures;
+        }
+      }
+
+      async getIndex() {
+        if (this.index || !this.config.indexURL) {
+          return this.index;
+        } else {
+          this.index = await this.loadIndex();
+          return this.index;
+        }
+      }
+      /**
+       * Return a Promise for the async loaded index
+       */
+
+
+      async loadIndex() {
+        const indexURL = this.config.indexURL;
+        return loadIndex(indexURL, this.config, this.genome);
+      }
+
+      async loadFeaturesFromDataURI() {
+        if (this.features) {
+          // An optimization hack for non-indexed files, features are temporarily cached when header is read.
+          const tmp = this.features;
+          delete this.features;
+          return tmp;
+        } else {
+          const plain = decodeDataURI$1(this.dataURI);
+          let dataWrapper = getDataWrapper(plain);
+          this.header = await this.parser.parseHeader(dataWrapper);
+
+          if (this.header instanceof String && this.header.startsWith("##gff-version 3")) {
+            this.format = 'gff3';
+          }
+
+          dataWrapper = getDataWrapper(plain);
+          this.features = await this.parser.parseFeatures(dataWrapper);
+          return this.features;
+        }
+      }
+
+    }
+
+    /*
+     * The MIT License (MIT)
+     *
+     * Copyright (c) 2016 University of California San Diego
+     * Author: Jim Robinson
+     *
+     * Permission is hereby granted, free of charge, to any person obtaining a copy
+     * of this software and associated documentation files (the "Software"), to deal
+     * in the Software without restriction, including without limitation the rights
+     * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+     * copies of the Software, and to permit persons to whom the Software is
+     * furnished to do so, subject to the following conditions:
+     *
+     * The above copyright notice and this permission notice shall be included in
+     * all copies or substantial portions of the Software.
+     *
+     *
+     * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+     * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+     * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+     * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+     * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+     * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+     * THE SOFTWARE.
+     */
+    const isString$4 = isString$6;
+
+    class CustomServiceReader {
+      constructor(config) {
+        this.config = config;
+      }
+
+      async readFeatures(chr, start, end) {
+        let url;
+
+        if (typeof this.config.url === 'function') {
+          url = this.config.url({
+            chr,
+            start,
+            end
+          });
+        } else {
+          url = this.config.url.replace("$CHR", chr).replace("$START", start).replace("$END", end);
+        }
+
+        let config = Object.assign({}, this.config);
+
+        if (this.config.body !== undefined) {
+          if (typeof this.config.body === 'function') {
+            config.body = this.config.body({
+              chr,
+              start,
+              end
+            });
+          } else {
+            config.body = this.config.body.replace("$CHR", chr).replace("$START", start).replace("$END", end);
+          }
+        }
+
+        let features;
+        const data = await igvxhr.load(url, config);
+
+        if (data) {
+          if (typeof this.config.parser === "function") {
+            features = this.config.parser(data);
+          } else if (isString$4(data)) {
+            features = JSON.parse(data);
+          } else {
+            features = data;
+          }
+        }
+
+        if (this.config.mappings) {
+          let mappingKeys = Object.keys(this.config.mappings);
+
+          for (let f of features) {
+            for (let key of mappingKeys) {
+              f[key] = f[this.config.mappings[key]];
+            }
+          }
+        }
+
+        return features;
+      }
+
+    }
+
+    /*
+     * The MIT License (MIT)
+     *
+     * Copyright (c) 2016-2017 The Regents of the University of California
+     * Author: Jim Robinson
+     *
+     * Permission is hereby granted, free of charge, to any person obtaining a copy
+     * of this software and associated documentation files (the "Software"), to deal
+     * in the Software without restriction, including without limitation the rights
+     * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+     * copies of the Software, and to permit persons to whom the Software is
+     * furnished to do so, subject to the following conditions:
+     *
+     * The above copyright notice and this permission notice shall be included in
+     * all copies or substantial portions of the Software.
+     *
+     *
+     * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+     * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+     * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+     * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+     * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+     * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+     * THE SOFTWARE.
+     */
+
+    const UCSCServiceReader = function (config, genome) {
+      this.config = config;
+      this.genome = genome;
+      this.expandQueryInterval = false;
+    };
+
+    UCSCServiceReader.prototype.readFeatures = function (chr, start, end) {
+      const s = Math.max(0, Math.floor(start));
+      let e = Math.ceil(end);
+
+      if (this.genome) {
+        const c = this.genome.getChromosome(chr);
+
+        if (c && e > c.bpLength) {
+          e = c.bpLength;
+        }
+      }
+
+      const url = this.config.url + '?db=' + this.config.db + '&table=' + this.config.tableName + '&chr=' + chr + '&start=' + s + '&end=' + e;
+      return igvxhr.loadJson(url, this.config).then(function (data) {
+        if (data) {
+          data.forEach(function (sample) {
+            if (sample.hasOwnProperty('exonStarts') && sample.hasOwnProperty('exonEnds') && sample.hasOwnProperty('exonCount') && sample.hasOwnProperty('cdsStart') && sample.hasOwnProperty('cdsEnd')) {
+              addExons(sample);
+            }
+          });
+          return data;
+        } else {
+          return null;
+        }
+      });
+    };
+
+    function addExons(sample) {
+      var exonCount, exonStarts, exonEnds, exons, eStart, eEnd;
+      exonCount = sample['exonCount'];
+      exonStarts = sample['exonStarts'].split(',');
+      exonEnds = sample['exonEnds'].split(',');
+      exons = [];
+
+      for (var i = 0; i < exonCount; i++) {
+        eStart = parseInt(exonStarts[i]);
+        eEnd = parseInt(exonEnds[i]);
+        var exon = {
+          start: eStart,
+          end: eEnd
+        };
+        if (sample.cdsStart > eEnd || sample.cdsEnd < sample.cdsStart) exon.utr = true; // Entire exon is UTR
+
+        if (sample.cdsStart >= eStart && sample.cdsStart <= eEnd) exon.cdStart = sample.cdsStart;
+        if (sample.cdsEnd >= eStart && sample.cdsEnd <= eEnd) exon.cdEnd = sample.cdsEnd;
+        exons.push(exon);
+      }
+
+      sample.exons = exons;
+    }
+
+    /*
+     * The MIT License (MIT)
+     *
+     * Copyright (c) 2016 University of California San Diego
+     * Author: Jim Robinson
+     *
+     * Permission is hereby granted, free of charge, to any person obtaining a copy
+     * of this software and associated documentation files (the "Software"), to deal
+     * in the Software without restriction, including without limitation the rights
+     * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+     * copies of the Software, and to permit persons to whom the Software is
+     * furnished to do so, subject to the following conditions:
+     *
+     * The above copyright notice and this permission notice shall be included in
+     * all copies or substantial portions of the Software.
+     *
+     *
+     * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+     * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+     * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+     * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+     * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+     * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+     * THE SOFTWARE.
+     */
+    /**
+     * Created by jrobinson on 4/7/16.
+     */
+
+    const transcriptTypes = new Set(['transcript', 'primary_transcript', 'processed_transcript', 'mRNA', 'mrna']);
+    const cdsTypes = new Set(['CDS', 'cds']);
+    const codonTypes = new Set(['start_codon', 'stop_codon']);
+    const utrTypes = new Set(['5UTR', '3UTR', 'UTR', 'five_prime_UTR', 'three_prime_UTR', "3'-UTR", "5'-UTR"]);
+    const exonTypes = new Set(['exon', 'coding-exon']);
+    const intronType = 'intron';
+
+    const transcriptModelTypes = new Set();
+
+    for (let cltn of [transcriptTypes, cdsTypes, codonTypes, utrTypes, exonTypes]) {
+      for (let t of cltn) {
+        transcriptModelTypes.add(t);
+      }
+    }
+
+    class GFFHelper {
+      constructor(options) {
+        this.format = options.format;
+        this.filterTypes = options.filterTypes === undefined ? new Set(['chromosome']) : new Set(options.filterTypes);
+      }
+
+      combineFeatures(features) {
+        let combinedFeatures;
+
+        if ("gff3" === this.format) {
+          const tmp = this.combineFeaturesById(features);
+          combinedFeatures = this.combineFeaturesGFF(tmp);
+        } else {
+          combinedFeatures = this.combineFeaturesGTF(features);
+        }
+
+        combinedFeatures.sort(function (a, b) {
+          return a.start - b.start;
+        });
+        return combinedFeatures;
+      }
+
+      combineFeaturesById(features) {
+        const combinedFeatures = [];
+        const chrIdHash = {};
+
+        for (let f of features) {
+          if (f.id === undefined) {
+            combinedFeatures.push(f);
+          } else {
+            let idHash = chrIdHash[f.chr];
+
+            if (!idHash) {
+              idHash = {};
+              chrIdHash[f.chr] = idHash;
+            }
+
+            if (idHash.hasOwnProperty(f.id)) {
+              const sf = idHash[f.id];
+
+              if (sf.hasOwnProperty("exons")) {
+                sf.start = Math.min(sf.start, f.start);
+                sf.end = Math.max(sf.end, f.end);
+                sf.exons.push(f);
+              } else {
+                const cf = {
+                  id: f.id,
+                  type: f.type,
+                  chr: f.chr,
+                  strand: f.strand,
+                  start: Math.min(f.start, sf.start),
+                  end: Math.max(f.end, sf.end),
+                  exons: [sf, f]
+                };
+
+                if (f.parent && f.parent.trim() !== "") {
+                  cf.parent = f.parent;
+                }
+
+                idHash[f.id] = cf;
+              }
+            } else {
+              idHash[f.id] = f;
+            }
+          }
+        }
+
+        for (let key of Object.keys(chrIdHash)) {
+          const idHash = chrIdHash[key];
+
+          for (let id of Object.keys(idHash)) {
+            combinedFeatures.push(idHash[id]);
+          }
+        }
+
+        return combinedFeatures;
+      }
+
+      combineFeaturesGTF(features) {
+        const transcripts = Object.create(null);
+        const combinedFeatures = [];
+        const consumedFeatures = new Set();
+        const filterTypes = this.filterTypes;
+        features = features.filter(f => filterTypes === undefined || !filterTypes.has(f.type)); // 1. Build dictionary of transcripts
+
+        for (let f of features) {
+          if (transcriptTypes.has(f.type)) {
+            const transcriptId = f.id;
+
+            if (undefined !== transcriptId) {
+              const gffTranscript = new GFFTranscript(f);
+              transcripts[transcriptId] = gffTranscript;
+              combinedFeatures.push(gffTranscript);
+              consumedFeatures.add(f);
+            }
+          }
+        } // Add exons
+
+
+        for (let f of features) {
+          if (exonTypes.has(f.type)) {
+            const id = f.id; // transcript_id,  GTF groups all features with the same ID, does not have a parent/child hierarchy
+
+            if (id) {
+              let transcript = transcripts[id];
+
+              if (transcript === undefined) {
+                transcript = new GFFTranscript(f); // GTF does not require an explicit transcript record
+
+                transcripts[id] = transcript;
+                combinedFeatures.push(transcript);
+              }
+
+              transcript.addExon(f);
+              consumedFeatures.add(f);
+            }
+          }
+        } // Apply CDS and UTR
+
+
+        for (let f of features) {
+          if (cdsTypes.has(f.type) || utrTypes.has(f.type) || codonTypes.has(f.type)) {
+            const id = f.id;
+
+            if (id) {
+              let transcript = transcripts[id];
+
+              if (transcript === undefined) {
+                transcript = new GFFTranscript(f);
+                transcripts[id] = transcript;
+                combinedFeatures.push(transcript);
+              }
+
+              if (utrTypes.has(f.type)) {
+                transcript.addUTR(f);
+              } else if (cdsTypes.has(f.type)) {
+                transcript.addCDS(f);
+              } else if (codonTypes.has(f.type)) ;
+
+              consumedFeatures.add(f);
+            }
+          }
+        } // Finish transcripts
+
+
+        for (let f of combinedFeatures) {
+          if (typeof f.finish === "function") {
+            f.finish();
+          }
+        } // Add other features
+
+
+        const others = features.filter(f => !consumedFeatures.has(f));
+
+        for (let f of others) {
+          combinedFeatures.push(f);
+        }
+
+        return combinedFeatures;
+      }
+
+      combineFeaturesGFF(features) {
+        // Build dictionary of genes (optional)
+        const genes = features.filter(f => "gene" === f.type);
+        const geneMap = Object.create(null);
+
+        for (let g of genes) {
+          geneMap[g.id] = g;
+        } // 1. Build dictionary of transcripts
+
+
+        const transcripts = Object.create(null);
+        const combinedFeatures = [];
+        const consumedFeatures = new Set();
+        const filterTypes = this.filterTypes;
+        features = features.filter(f => filterTypes === undefined || !filterTypes.has(f.type));
+
+        for (let f of features) {
+          if (transcriptTypes.has(f.type)) {
+            const transcriptId = f.id; // getAttribute(f.attributeString, "transcript_id", /\s+/);
+
+            if (undefined !== transcriptId) {
+              const gffTranscript = new GFFTranscript(f);
+              transcripts[transcriptId] = gffTranscript;
+              combinedFeatures.push(gffTranscript);
+              consumedFeatures.add(f);
+              const g = geneMap[f.parent];
+
+              if (g) {
+                gffTranscript.gene = geneMap[f.parent];
+                consumedFeatures.add(g);
+              }
+            }
+          }
+        } // Remove assigned genes
+        // Add exons
+
+
+        for (let f of features) {
+          if (exonTypes.has(f.type)) {
+            const parents = getParents(f);
+
+            if (parents) {
+              for (let id of parents) {
+                let transcript = transcripts[id];
+
+                if (transcript !== undefined) {
+                  transcript.addExon(f);
+                  consumedFeatures.add(f);
+                }
+              }
+            }
+          }
+        } // Apply CDS and UTR
+
+
+        for (let f of features) {
+          if (cdsTypes.has(f.type) || utrTypes.has(f.type) || codonTypes.has(f.type)) {
+            const parents = getParents(f);
+
+            if (parents) {
+              for (let id of parents) {
+                let transcript = transcripts[id];
+
+                if (transcript !== undefined) {
+                  if (utrTypes.has(f.type)) {
+                    transcript.addUTR(f);
+                  } else if (cdsTypes.has(f.type)) {
+                    transcript.addCDS(f);
+                  } else if (codonTypes.has(f.type)) ;
+
+                  consumedFeatures.add(f);
+                }
+              }
+            }
+          }
+        } // Introns are ignored, but are consumed
+
+
+        const introns = features.filter(f => intronType === f.type);
+
+        for (let i of introns) {
+          const parents = getParents(i);
+
+          for (let id of parents) {
+            if (transcripts[id]) {
+              consumedFeatures.add(i);
+              break;
+            }
+          }
+        } // Finish transcripts
+
+
+        combinedFeatures.forEach(function (f) {
+          if (typeof f.finish === "function") {
+            f.finish();
+          }
+        }); // Add other features
+
+        const others = features.filter(f => !consumedFeatures.has(f));
+
+        for (let f of others) {
+          combinedFeatures.push(f);
+        }
+
+        return combinedFeatures;
+
+        function getParents(f) {
+          if (f.parent && f.parent.trim() !== "") {
+            return f.parent.trim().split(",");
+          } else {
+            return null;
+          }
+        }
+      }
+
+    }
+
+    var GFFTranscript = function (feature) {
+      Object.assign(this, feature);
+      this.exons = [];
+    };
+
+    GFFTranscript.prototype.addExon = function (feature) {
+      this.exons.push(feature); // Expand feature --  for transcripts not explicitly represented in the file
+
+      this.start = Math.min(this.start, feature.start);
+      this.end = Math.max(this.end, feature.end);
+    };
+
+    GFFTranscript.prototype.addCDS = function (cds) {
+      let exon;
+      const exons = this.exons; // Find exon containing CDS
+
+      for (let i = 0; i < exons.length; i++) {
+        if (exons[i].start <= cds.start && exons[i].end >= cds.end) {
+          exon = exons[i];
+          break;
+        }
+      }
+
+      if (exon) {
+        exon.cdStart = exon.cdStart ? Math.min(cds.start, exon.cdStart) : cds.start;
+        exon.cdEnd = exon.cdEnd ? Math.max(cds.end, exon.cdEnd) : cds.end;
+
+        if (!exon.children) {
+          exon.children = [];
+        }
+
+        exon.children.push(cds);
+      } else {
+        cds.cdStart = cds.start;
+        cds.cdEnd = cds.end;
+        exons.push(cds);
+      } // Expand feature --  for transcripts not explicitly represented in the file (gtf files)
+
+
+      this.start = Math.min(this.start, cds.start);
+      this.end = Math.max(this.end, cds.end);
+      this.cdStart = this.cdStart ? Math.min(cds.start, this.cdStart) : cds.start;
+      this.cdEnd = this.cdEnd ? Math.max(cds.end, this.cdEnd) : cds.end;
+    };
+
+    GFFTranscript.prototype.addUTR = function (utr) {
+      let exon;
+      const exons = this.exons; // Find exon containing CDS
+
+      for (let i = 0; i < exons.length; i++) {
+        if (exons[i].start <= utr.start && exons[i].end >= utr.end) {
+          exon = exons[i];
+          break;
+        }
+      }
+
+      if (exon) {
+        if (utr.start === exon.start && utr.end === exon.end) {
+          exon.utr = true;
+        } else {
+          if (utr.end < exon.end) {
+            exon.cdStart = utr.end;
+          }
+
+          if (utr.start > exon.start) {
+            exon.cdEnd = utr.start;
+          }
+        }
+
+        if (!exon.children) {
+          exon.children = [];
+        }
+
+        exon.children.push(utr);
+      } else {
+        utr.utr = true;
+        exons.push(utr);
+      } // Expand feature --  for transcripts not explicitly represented in the file
+
+
+      this.start = Math.min(this.start, utr.start);
+      this.end = Math.max(this.end, utr.end);
+    };
+
+    GFFTranscript.prototype.finish = function () {
+      var cdStart = this.cdStart;
+      var cdEnd = this.cdEnd;
+      this.exons.sort(function (a, b) {
+        return a.start - b.start;
+      }); // Search for UTR exons that were not explicitly tagged
+
+      if (cdStart) {
+        this.exons.forEach(function (exon) {
+          if (exon.end < cdStart || exon.start > cdEnd) exon.utr = true;
+        });
+      }
+    };
+
+    GFFTranscript.prototype.popupData = function (genomicLocation) {
+      const kvs = this.attributeString.split(';');
+      const pd = []; // If feature has an associated gene list its attributes first
+
+      if (this.gene && typeof this.gene.popupData === 'function') {
+        const gd = this.gene.popupData(genomicLocation);
+
+        for (let e of gd) {
+          pd.push(e);
+        }
+
+        pd.push("<hr>");
+      }
+
+      if (this.name) {
+        pd.push({
+          name: 'name',
+          value: this.name
+        });
+      }
+
+      pd.push({
+        name: 'type',
+        value: this.type
+      });
+
+      for (let kv of kvs) {
+        var t = kv.trim().split(this.delim, 2);
+
+        if (t.length === 2 && t[1] !== undefined) {
+          const key = t[0].trim();
+          if ('name' === key.toLowerCase()) continue;
+          let value = t[1].trim(); //Strip off quotes, if any
+
+          if (value.startsWith('"') && value.endsWith('"')) {
+            value = value.substr(1, value.length - 2);
+          }
+
+          pd.push({
+            name: key,
+            value: value
+          });
+        }
+      }
+
+      pd.push({
+        name: 'position',
+        value: `${this.chr}:${numberFormatter$1(this.start + 1)}-${numberFormatter$1(this.end)}`
+      }); // If clicked over an exon add its attributes
+
+      for (let exon of this.exons) {
+        if (genomicLocation >= exon.start && genomicLocation < exon.end && typeof exon.popupData === 'function') {
+          pd.push("<hr>");
+          const exonData = exon.popupData(genomicLocation);
+
+          for (let att of exonData) {
+            pd.push(att);
+          }
+
+          if (exon.children) {
+            for (let c of exon.children) {
+              pd.push("<hr>");
+              const exonData = c.popupData(genomicLocation);
+
+              for (let att of exonData) {
+                pd.push(att);
+              }
+            }
+          }
+        }
+      }
+
+      return pd;
+    };
+
+    /*
+     * The MIT License (MIT)
+     *
+     * Copyright (c) 2015 UC San Diego
+     *
+     * Permission is hereby granted, free of charge, to any person obtaining a copy
+     * of this software and associated documentation files (the "Software"), to deal
+     * in the Software without restriction, including without limitation the rights
+     * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+     * copies of the Software, and to permit persons to whom the Software is
+     * furnished to do so, subject to the following conditions:
+     *
+     * The above copyright notice and this permission notice shall be included in
+     * all copies or substantial portions of the Software.
+     *
+     *
+     * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+     * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+     * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+     * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+     * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+     * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+     * THE SOFTWARE.
+     */
+
+    const GtexReader = function (config) {
+      this.config = config;
+      this.url = config.url;
+      this.tissueId = config.tissueSiteDetailId;
+      this.indexed = true;
+      this.datasetId = config.datasetId || "gtex_v8";
+    };
+
+    GtexReader.prototype.readFeatures = async function (chr, bpStart, bpEnd) {
+      let self = this,
+          queryChr = chr.startsWith("chr") ? chr : "chr" + chr,
+          queryStart = Math.floor(bpStart),
+          queryEnd = Math.ceil(bpEnd),
+          datasetId = this.datasetId,
+          queryURL = this.url + "?chromosome=" + queryChr + "&start=" + queryStart + "&end=" + queryEnd + "&tissueSiteDetailId=" + this.tissueId + "&datasetId=" + datasetId;
+      const json = await igvxhr.loadJson(queryURL, {
+        withCredentials: self.config.withCredentials
+      });
+
+      if (json && json.singleTissueEqtl) {
+        //variants = json.variants;
+        //variants.sort(function (a, b) {
+        //    return a.POS - b.POS;
+        //});
+        //source.cache = new FeatureCache(chr, queryStart, queryEnd, variants);
+        json.singleTissueEqtl.forEach(function (eqtl) {
+          eqtl.chr = eqtl.chromosome;
+          eqtl.position = eqtl.pos;
+          eqtl.start = eqtl.pos - 1;
+          eqtl.end = eqtl.start + 1;
+          eqtl.snp = eqtl.snpId;
+          eqtl.geneName = eqtl.geneSymbol;
+          eqtl.geneId = eqtl.gencodeId;
+        });
+        return json.singleTissueEqtl;
+      } else {
+        return undefined;
+      }
+    };
+
+    /*
+     * The MIT License (MIT)
+     *
+     * Copyright (c) 2014 Broad Institute
+     *
+     * Permission is hereby granted, free of charge, to any person obtaining a copy
+     * of this software and associated documentation files (the "Software"), to deal
+     * in the Software without restriction, including without limitation the rights
+     * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+     * copies of the Software, and to permit persons to whom the Software is
+     * furnished to do so, subject to the following conditions:
+     *
+     * The above copyright notice and this permission notice shall be included in
+     * all copies or substantial portions of the Software.
+     *
+     *
+     * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+     * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+     * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+     * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+     * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+     * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+     * THE SOFTWARE.
+     */
+    // http://immvar.broadinstitute.org:3000/load_data?chromosome=&start=&end=&categories=
+
+    const ImmVarReader = function (config) {
+      this.config = config;
+      this.url = config.url;
+      this.cellConditionId = config.cellConditionId;
+      this.valueThreshold = config.valueThreshold ? config.valueThreshold : 5E-2;
+    };
+
+    ImmVarReader.prototype.readFeatures = function (queryChr, queryStart, queryEnd) {
+      var self = this,
+          queryURL = this.url + "?chromosome=" + queryChr + "&start=" + queryStart + "&end=" + queryEnd + "&cell_condition_id=" + this.cellConditionId;
+      return new Promise(function (fulfill, reject) {
+        igvxhr.loadJson(queryURL, {
+          withCredentials: self.config.withCredentials
+        }).then(function (json) {
+          if (json) {
+            //variants = json.variants;
+            //variants.sort(function (a, b) {
+            //    return a.POS - b.POS;
+            //});
+            //source.cache = new FeatureCache(chr, queryStart, queryEnd, variants);
+            json.eqtls.forEach(function (eqtl) {
+              eqtl.chr = eqtl.chromosome;
+              eqtl.start = eqtl.position;
+              eqtl.end = eqtl.position + 1;
+            });
+            fulfill(json.eqtls);
+          } else {
+            fulfill(null);
+          }
+        }).catch(function (error) {
+          reject(error);
+        });
+      });
+    };
+
+    /*
+     * The MIT License (MIT)
+     *
+     * Copyright (c) 2014 Broad Institute
+     *
+     * Permission is hereby granted, free of charge, to any person obtaining a copy
+     * of this software and associated documentation files (the "Software"), to deal
+     * in the Software without restriction, including without limitation the rights
+     * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+     * copies of the Software, and to permit persons to whom the Software is
+     * furnished to do so, subject to the following conditions:
+     *
+     * The above copyright notice and this permission notice shall be included in
+     * all copies or substantial portions of the Software.
+     *
+     *
+     * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+     * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+     * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+     * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+     * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+     * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+     * THE SOFTWARE.
+     */
+    const apiKey = igvxhr.apiKey;
+
+    function ga4ghGet(options) {
+      var url = options.url + "/" + options.entity + "/" + options.entityId;
+      options.headers = ga4ghHeaders();
+      return igvxhr.loadJson(url, options); // Returns a promise
+    }
+
+    function ga4ghSearch(options) {
+      return new Promise(function (fulfill, reject) {
+        var results = options.results ? options.results : [],
+            url = options.url,
+            body = options.body,
+            decode = options.decode,
+            paramSeparator = "?",
+            fields = options.fields; // Partial response
+
+        if (apiKey) {
+          url = url + paramSeparator + "key=" + apiKey;
+          paramSeparator = "&";
+        }
+
+        if (fields) {
+          url = url + paramSeparator + "fields=" + fields;
+        } // Start the recursive load cycle.  Data is fetched in chunks, if more data is available a "nextPageToken" is returned.
+
+
+        return loadChunk();
+
+        function loadChunk(pageToken) {
+          if (pageToken) {
+            body.pageToken = pageToken;
+          } else {
+            if (body.pageToken !== undefined) delete body.pageToken; // Remove previous page token, if any
+          }
+
+          var sendData = JSON.stringify(body);
+          igvxhr.loadJson(url, {
+            sendData: sendData,
+            contentType: "application/json",
+            headers: ga4ghHeaders() //    oauthToken: ga4ghToken()
+
+          }).then(function (json) {
+            var nextPageToken, tmp;
+
+            if (json) {
+              tmp = decode ? decode(json) : json;
+
+              if (tmp) {
+                tmp.forEach(function (a) {
+
+                  {
+                    results.push(a);
+                  }
+                });
+              }
+
+              nextPageToken = json["nextPageToken"];
+
+              if (nextPageToken) {
+                loadChunk(nextPageToken);
+              } else {
+                fulfill(results);
+              }
+            } else {
+              fulfill(results);
+            }
+          }).catch(function (error) {
+            reject(error);
+          });
+        }
+      });
+    }
+
+    function ga4ghHeaders() {
+      return {
+        "Cache-Control": "no-cache"
+      };
+    }
+
+    /*
+     * The MIT License (MIT)
+     *
+     * Copyright (c) 2014 Broad Institute
+     *
+     * Permission is hereby granted, free of charge, to any person obtaining a copy
+     * of this software and associated documentation files (the "Software"), to deal
+     * in the Software without restriction, including without limitation the rights
+     * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+     * copies of the Software, and to permit persons to whom the Software is
+     * furnished to do so, subject to the following conditions:
+     *
+     * The above copyright notice and this permission notice shall be included in
+     * all copies or substantial portions of the Software.
+     *
+     *
+     * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+     * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+     * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+     * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+     * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+     * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+     * THE SOFTWARE.
+     */
+
+    const Ga4ghVariantReader = function (config, genome) {
+      this.config = config;
+      this.genome = genome;
+      this.url = config.url;
+      this.variantSetId = config.variantSetId;
+      this.callSetIds = config.callSetIds;
+      this.includeCalls = config.includeCalls === undefined ? true : config.includeCalls;
+    }; // Simulate a VCF file header
+
+
+    Ga4ghVariantReader.prototype.readHeader = function () {
+      var self = this;
+
+      if (self.header) {
+        return Promise.resolve(self.header);
+      } else {
+        self.header = {};
+
+        if (self.includeCalls === false) {
+          return Promise.resolve(self.header);
+        } else {
+          var readURL = self.url + "/callsets/search";
+          return ga4ghSearch({
+            url: readURL,
+            fields: "nextPageToken,callSets(id,name)",
+            body: {
+              "variantSetIds": Array.isArray(self.variantSetId) ? self.variantSetId : [self.variantSetId],
+              "pageSize": "10000"
+            },
+            decode: function (json) {
+              // If specific callSetIds are specified filter to those
+              if (self.callSetIds) {
+                var callSets = [],
+                    csIdSet = new Set();
+                self.callSetIds.forEach(function (csid) {
+                  csIdSet.add(csid);
+                });
+                json.callSets.forEach(function (cs) {
+                  if (csIdSet.has(cs.id)) {
+                    callSets.push(cs);
+                  }
+                });
+                return callSets;
+              } else {
+                return json.callSets;
+              }
+            }
+          }).then(function (callSets) {
+            self.header.callSets = callSets;
+            return self.header;
+          });
+        }
+      }
+    };
+
+    Ga4ghVariantReader.prototype.readFeatures = function (chr, bpStart, bpEnd) {
+      const self = this;
+      const genome = this.genome;
+      return self.readHeader().then(function (header) {
+        return getChrAliasTable();
+      }).then(function (chrAliasTable) {
+        var queryChr = chrAliasTable.hasOwnProperty(chr) ? chrAliasTable[chr] : chr,
+            readURL = self.url + "/variants/search";
+        return ga4ghSearch({
+          url: readURL,
+          fields: self.includeCalls ? undefined : "nextPageToken,variants(id,variantSetId,names,referenceName,start,end,referenceBases,alternateBases,quality,filter,info)",
+          body: {
+            "variantSetIds": Array.isArray(self.variantSetId) ? self.variantSetId : [self.variantSetId],
+            "callSetIds": self.callSetIds ? self.callSetIds : undefined,
+            "referenceName": queryChr,
+            "start": bpStart.toString(),
+            "end": bpEnd.toString(),
+            "pageSize": "10000"
+          },
+          decode: function (json) {
+            var v;
+            var variants = [];
+            json.variants.forEach(function (json) {
+              v = createGAVariant(json);
+
+              if (!v.isRefBlock()) {
+                variants.push(v);
+              }
+            });
+            return variants;
+          }
+        });
+      });
+
+      function getChrAliasTable() {
+        return new Promise(function (fulfill, reject) {
+          if (self.chrAliasTable) {
+            fulfill(self.chrAliasTable);
+          } else {
+            self.readMetadata().then(function (json) {
+              self.metadata = json.metadata;
+              self.chrAliasTable = {};
+
+              if (json.referenceBounds && genome) {
+                json.referenceBounds.forEach(function (rb) {
+                  var refName = rb.referenceName,
+                      alias = genome.getChromosomeName(refName);
+                  self.chrAliasTable[alias] = refName;
+                });
+              }
+
+              fulfill(self.chrAliasTable);
+            });
+          }
+        });
+      }
+    };
+
+    Ga4ghVariantReader.prototype.readMetadata = function () {
+      return ga4ghGet({
+        url: this.url,
+        entity: "variantsets",
+        entityId: this.variantSetId
+      });
+    };
+
+    class CivicReader {
+      constructor(config) {
+        this.config = config;
+      }
+
+      async readFeatures(chr, start, end) {
+        const json = await igvxhr.loadJson(this.config.url + "/variants/?count=50000");
+        const records = json.records;
+        const features = [];
+
+        for (let record of records) {
+          if (record.coordinates) {
+            record.id;
+            const coordinates = record.coordinates;
+
+            if (coordinates.chromosome) {
+              features.push(new CivicVariant(coordinates.chromosome, coordinates.start - 1, // UCSC 0 convention
+              coordinates.stop, record));
+            }
+
+            if (coordinates.chromosome2) {
+              features.push(new CivicVariant(coordinates.chromosome2, coordinates.start2 - 1, // UCSC 0 convention
+              coordinates.stop2, record));
+            }
+          }
+        }
+
+        return features;
+      }
+
+    }
+
+    class CivicVariant {
+      constructor(chr, start, end, record) {
+        this.chr = chr;
+        this.start = start;
+        this.end = end;
+        this.id = record.id;
+        this.entrezName = record.entrez_name;
+        this.name = record.name;
+        this.actionabilityScore = record.civic_actionability_score;
+
+        if (record.coordinates.reference_bases) {
+          this.refBases = record.coordinates.reference_bases;
+        }
+
+        if (record.coordinates.variant_bases) {
+          this.altBases = record.coordinates.variant_bases;
+        }
+
+        if (record.variant_types) {
+          this.variant_types = record.variant_types;
+        }
+
+        this.locationString = this.chr + ":" + numberFormatter$1(this.start + 1) + "-" + numberFormatter$1(this.end); // Color based on actionability score
+
+        if (this.actionabilityScore !== undefined) {
+          let alpha;
+
+          if (this.actionabilityScore <= 10) {
+            alpha = 0.2;
+          } else {
+            const v = Math.min(30, this.actionabilityScore);
+            alpha = 0.2 + 0.8 * Math.log10((v - 10) / 2);
+          }
+
+          this.alpha = alpha;
+        }
+      }
+
+      popupData() {
+        const link = createLink("CIViC", "https://civicdb.org/links/variants/" + this.id);
+        this.refBases !== this.altBases && this.refBases && this.refBases.length === 1 && this.altBases && this.altBases.length === 1;
+        const pd = [link];
+        pd.push({
+          name: "Entrez",
+          value: createLink(this.entrezName, "https://ghr.nlm.nih.gov/gene/" + this.entrezName)
+        });
+        pd.push({
+          name: "Name",
+          value: this.name
+        });
+
+        if (this.variant_types && this.variant_types.length > 0) {
+          const name = this.variant_types.length === 1 ? "Type" : "Types";
+          let typeString;
+
+          for (let vt of this.variant_types) {
+            if (!typeString) typeString = vt.display_name;else typeString += ", " + vt.display_name;
+          }
+
+          pd.push({
+            name: name,
+            value: typeString
+          });
+        }
+
+        pd.push({
+          name: "Actionability",
+          value: this.actionabilityScore
+        });
+        pd.push({
+          name: "Location",
+          value: this.locationString
+        });
+        return pd;
+
+        function createLink(text, href) {
+          return "<a target='_blank' " + "href='" + href + "'>" + text + "</a>";
+        }
+      }
+
+    }
+
+    // Assigns a row # to each feature.  If the feature does not fit in any row and #rows == maxRows no
+    // row number is assigned.
+    function pack(featureList, maxRows) {
+      maxRows = maxRows || Number.MAX_SAFE_INTEGER;
+      const rows = [];
+      featureList.sort(function (a, b) {
+        return a.start - b.start;
+      });
+      rows.push(-1000);
+
+      for (let feature of featureList) {
+        let r = 0;
+        const len = Math.min(rows.length, maxRows);
+
+        for (r = 0; r < len; r++) {
+          if (feature.start > rows[r]) {
+            feature.row = r;
+            rows[r] = feature.end;
+            break;
+          }
+        }
+
+        feature.row = r;
+        rows[r] = feature.end;
+      }
+    }
+
+    class HtsgetReader {
+      constructor(config, genome) {
+        this.config = config;
+        this.genome = genome;
+        this.format = config.format ? config.format.toUpperCase() : "BAM"; // Backward compatibility
+
+        if (!(this.format === "BAM" || this.format === "VCF")) {
+          throw Error(`htsget format ${config.format} is not supported`);
+        }
+      }
+
+      async readHeaderData() {
+        const url = `${getUrl(this.config)}?class=header&format=${this.format}`;
+        const ticket = await igvxhr.loadJson(url, buildOptions(this.config));
+        return await this.loadUrls(ticket.htsget.urls);
+      }
+
+      async readData(chr, start, end) {
+        const url = `${getUrl(this.config)}?format=${this.format}&referenceName=${chr}&start=${Math.floor(start)}&end=${Math.ceil(end)}`;
+        const ticket = await igvxhr.loadJson(url, buildOptions(this.config));
+        return this.loadUrls(ticket.htsget.urls);
+      }
+
+      async loadUrls(urls) {
+        const promiseArray = [];
+
+        for (let urlData of urls) {
+          if (urlData.url.startsWith('data:')) {
+            // this is a data-uri
+            promiseArray.push(Promise.resolve(dataUriToBytes(urlData.url)));
+          } else {
+            const options = buildOptions(this.config || {});
+
+            if (urlData.headers) {
+              options.headers = Object.assign(options.headers || {}, urlData.headers);
+            }
+
+            promiseArray.push(igvxhr.loadArrayBuffer(urlData.url, options));
+          }
+        }
+
+        const arrayBuffers = await Promise.all(promiseArray);
+        return concatArrays(arrayBuffers);
+      }
+
+      static async inferFormat(config) {
+        try {
+          const url = getUrl(config);
+          const headerURL = `${url}${url.includes("?") ? "&" : "?"}class=header`;
+          const ticket = await igvxhr.loadJson(headerURL, buildOptions(config));
+
+          if (ticket.htsget) {
+            const format = ticket.htsget.format;
+
+            if (!(format === "BAM" || format === "VCF")) {
+              throw Error(`htsget format ${format} is not supported`);
+            }
+
+            config.format = format.toLowerCase();
+            config.sourceType = "htsget";
+
+            if (!config.name) {
+              config.name = await getFilename(config.url);
+            }
+          }
+        } catch (e) {// Errors => this is not an htsget source, not an application error.  Ignore
+        }
+      }
+
+    }
+    /**
+     * Extract the full url from the config.  Striving for backward compatibility, "endpoint" and "id" are deprecated.
+     *
+     * @param config
+     */
+
+
+    function getUrl(config) {
+      if (config.url && config.endpoint && config.id) {
+        return config.url + config.endpoint + config.id; // Deprecated
+      } else if (config.endpoint && config.id) {
+        return config.endpoint + config.id; // Deprecated
+      } else if (config.url) {
+        if (config.url.startsWith("htsget://")) {
+          return config.url.replace("htsget://", "https://"); // htsget -> http not supported
+        } else {
+          return config.url;
+        }
+      } else {
+        throw Error("Must specify either 'url', or 'endpoint' and 'id");
+      }
+    }
+    /**
+     * Concatenate a list of array buffers, returning an UInt8Array
+     * @param arrayBuffers
+     */
+
+
+    function concatArrays(arrayBuffers) {
+      let len = 0;
+
+      for (let a of arrayBuffers) {
+        len += a.byteLength;
+      }
+
+      let offset = 0;
+      const newArray = new Uint8Array(len);
+
+      for (let buf of arrayBuffers) {
+        const a = new Uint8Array(buf);
+        newArray.set(a, offset);
+        offset += a.length;
+      }
+
+      return newArray;
+    }
+
+    function dataUriToBytes(dataUri) {
+      const split = dataUri.split(',');
+      const info = split[0].split(':')[1];
+      let dataString = split[1];
+
+      if (info.indexOf('base64') >= 0) {
+        dataString = atob(dataString);
+      } else {
+        dataString = decodeURI(dataString);
+      }
+
+      const bytes = new Uint8Array(dataString.length);
+
+      for (var i = 0; i < dataString.length; i++) {
+        bytes[i] = dataString.charCodeAt(i);
+      }
+
+      return bytes;
+    }
+
+    /*
+     * The MIT License (MIT)
+     *
+     * Copyright (c) 2016-2017 The Regents of the University of California
+     * Author: Jim Robinson
+     *
+     * Permission is hereby granted, free of charge, to any person obtaining a copy
+     * of this software and associated documentation files (the "Software"), to deal
+     * in the Software without restriction, including without limitation the rights
+     * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+     * copies of the Software, and to permit persons to whom the Software is
+     * furnished to do so, subject to the following conditions:
+     *
+     * The above copyright notice and this permission notice shall be included in
+     * all copies or substantial portions of the Software.
+     *
+     *
+     * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+     * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+     * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+     * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+     * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+     * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+     * THE SOFTWARE.
+     */
+
+    class HtsgetVariantReader extends HtsgetReader {
+      constructor(config, genome) {
+        super(config, genome);
+        this.parser = new VcfParser();
+      }
+
+      async readHeader() {
+        if (!this.header) {
+          const data = await this.readHeaderData();
+          const dataWrapper = getDataWrapper(data);
+          this.header = await this.parser.parseHeader(dataWrapper, this.genome);
+          this.chrAliasTable = this.header.chrAliasTable;
+        }
+
+        return this.header;
+      }
+
+      async readFeatures(chr, start, end) {
+        if (this.config.format && this.config.format.toUpperCase() !== "VCF") {
+          throw Error(`htsget format ${this.config.format} is not supported`);
+        }
+
+        if (!this.chrAliasTable) {
+          await this.readHeader();
+        }
+
+        let queryChr = this.chrAliasTable.has(chr) ? this.chrAliasTable.get(chr) : chr;
+        const data = await this.readData(queryChr, start, end);
+        const dataWrapper = getDataWrapper(data);
+        return this.parser.parseFeatures(dataWrapper); //  return dataWrapper;
+      }
+
+    }
+
+    /*
+     * The MIT License (MIT)
+     *
+     * Copyright (c) 2014-2015 Broad Institute
+     *
+     * Permission is hereby granted, free of charge, to any person obtaining a copy
+     * of this software and associated documentation files (the "Software"), to deal
+     * in the Software without restriction, including without limitation the rights
+     * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+     * copies of the Software, and to permit persons to whom the Software is
+     * furnished to do so, subject to the following conditions:
+     *
+     * The above copyright notice and this permission notice shall be included in
+     * all copies or substantial portions of the Software.
+     *
+     *
+     * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+     * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+     * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+     * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+     * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+     * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+     * THE SOFTWARE.
+     */
+    /**
+     * feature source for "bed like" files (tab or whitespace delimited files with 1 feature per line: bed, gff, vcf, etc)
+     *
+     * @param config
+     * @constructor
+     */
+
+    class TextFeatureSource {
+      constructor(config, genome) {
+        this.config = config || {};
+        this.genome = genome;
+        this.sourceType = config.sourceType === undefined ? "file" : config.sourceType;
+        this.visibilityWindow = config.visibilityWindow;
+        const queryableFormats = new Set(["bigwig", "bw", "bigbed", "bb", "tdf"]);
+
+        if (config.features && Array.isArray(config.features)) {
+          let features = fixFeatures(config.features, genome);
+          packFeatures(features);
+
+          if (config.mappings) {
+            mapProperties(features, config.mappings);
+          }
+
+          this.queryable = false;
+          this.featureCache = new FeatureCache(features, genome);
+        } else if (config.reader) {
+          this.reader = config.reader;
+          this.queryable = config.queryable !== undefined ? config.queryable : true;
+          this.expandQuery = config.expandQuery ? true : false;
+        } else if (config.sourceType === "ga4gh") {
+          this.reader = new Ga4ghVariantReader(config, genome);
+          this.queryable = true;
+        } else if (config.sourceType === "immvar") {
+          this.reader = new ImmVarReader(config);
+          this.queryable = true;
+        } else if (config.type === "eqtl" && config.sourceType === "gtex-ws") {
+          this.reader = new GtexReader(config);
+          this.queryable = true;
+          this.expandQuery = config.expandQuery ? true : false;
+        } else if ("htsget" === config.sourceType) {
+          this.reader = new HtsgetVariantReader(config, genome);
+        } else if (config.sourceType === 'ucscservice') {
+          this.reader = new UCSCServiceReader(config.source);
+          this.queryable = true;
+        } else if (config.sourceType === 'custom' || config.source !== undefined) {
+          // Second test for backward compatibility
+          this.reader = new CustomServiceReader(config.source);
+          this.queryable = config.source.queryable !== undefined ? config.source.queryable : true;
+          this.expandQuery = config.expandQuery ? true : false;
+        } else if ("civic-ws" === config.sourceType) {
+          this.reader = new CivicReader(config);
+          this.queryable = false;
+          this.expandQuery = config.expandQuery ? true : false;
+        } else {
+          this.reader = new FeatureFileReader(config, genome);
+
+          if (config.queryable !== undefined) {
+            this.queryable = config.queryable;
+          } else if (queryableFormats.has(config.format)) {
+            this.queryable = queryableFormats.has(config.format) || this.reader.indexed;
+          } else ;
+        }
+      }
+
+      supportsWholeGenome() {
+        return !this.queryable && (this.visibilityWindow === undefined || this.visibilityWindow <= 0);
+      }
+
+      async trackType() {
+        const header = await this.getHeader();
+
+        if (header) {
+          return header.type;
+        } else {
+          return undefined; // Convention for unknown or unspecified
+        }
+      }
+
+      async getHeader() {
+        if (!this.header) {
+          if (this.reader && typeof this.reader.readHeader === "function") {
+            const header = await this.reader.readHeader();
+
+            if (header) {
+              this.header = header;
+
+              if (header.format) {
+                this.config.format = header.format;
+              }
+            } else {
+              this.header = {};
+            }
+          } else {
+            this.header = {};
+          }
+        }
+
+        return this.header;
+      }
+      /**
+       * Required function for all data source objects.  Fetches features for the
+       * range requested.
+       *
+       * This function is quite complex due to the variety of reader types backing it, some indexed, some queryable,
+       * some not.  The whole scheme could use a refactoring.
+       *
+       * @param chr
+       * @param start
+       * @param end
+       * @param bpPerPixel
+       */
+
+
+      async getFeatures({
+        chr,
+        start,
+        end,
+        bpPerPixel,
+        visibilityWindow
+      }) {
+        const genome = this.genome;
+        const queryChr = genome ? genome.getChromosomeName(chr) : chr;
+        const isWholeGenome = "all" === queryChr.toLowerCase(); // Various conditions that can create a feature load
+        // * view is "whole genome" but no features are loaded
+        // * cache is disabled
+        // * cache does not contain requested range
+
+        if (isWholeGenome && !this.getWGFeatures || this.config.disableCache || !this.featureCache || !this.featureCache.containsRange(new GenomicInterval(queryChr, start, end))) {
+          await this.loadFeatures(start, end, visibilityWindow, queryChr);
+        }
+
+        if (isWholeGenome) {
+          if (!this.wgFeatures) {
+            if (this.queryable) {
+              // queryable sources don't support whole genome view
+              this.wgFeatures = [];
+            } else {
+              this.wgFeatures = this.getWGFeatures(this.featureCache.getAllFeatures());
+            }
+          }
+
+          return this.wgFeatures;
+        } else {
+          return this.featureCache.queryFeatures(queryChr, start, end);
+        }
+      }
+
+      async loadFeatures(start, end, visibilityWindow, queryChr) {
+        const reader = this.reader;
+        let intervalStart = start;
+        let intervalEnd = end; // Use visibility window to potentially expand query interval.
+        // This can save re-queries as we zoom out.  Visibility window <= 0 is a special case
+        // indicating whole chromosome should be read at once.
+
+        if ((!visibilityWindow || visibilityWindow <= 0) && this.expandQuery !== false) {
+          // Whole chromosome
+          const chromosome = this.genome ? this.genome.getChromosome(queryChr) : undefined;
+          intervalStart = 0;
+          intervalEnd = chromosome ? chromosome.bpLength : Number.MAX_SAFE_INTEGER;
+        } else if (visibilityWindow > end - start && this.expandQuery !== false) {
+          const expansionWindow = Math.min(4.1 * (end - start), visibilityWindow);
+          intervalStart = Math.max(0, (start + end) / 2 - expansionWindow);
+          intervalEnd = start + expansionWindow;
+        }
+
+        let features = await reader.readFeatures(queryChr, intervalStart, intervalEnd);
+
+        if (this.queryable === undefined) {
+          this.queryable = reader.indexed;
+        }
+
+        const genomicInterval = this.queryable ? new GenomicInterval(queryChr, intervalStart, intervalEnd) : undefined;
+
+        if (features) {
+          if ("gtf" === this.config.format || "gff3" === this.config.format || "gff" === this.config.format) {
+            features = new GFFHelper(this.config).combineFeatures(features);
+          } // Assign overlapping features to rows
+
+
+          if (this.config.format !== "wig" && this.config.type !== "junctions") {
+            const maxRows = this.config.maxRows || Number.MAX_SAFE_INTEGER;
+            packFeatures(features, maxRows);
+          } // Note - replacing previous cache with new one.  genomicInterval is optional (might be undefined => includes all features)
+
+
+          this.featureCache = new FeatureCache(features, this.genome, genomicInterval); // If track is marked "searchable"< cache features by name -- use this with caution, memory intensive
+
+          if (this.config.searchable) {
+            this.addFeaturesToDB(features);
+          }
+        } else {
+          this.featureCache = new FeatureCache([], genomicInterval); // Empty cache
+        }
+      }
+
+      addFeaturesToDB(featureList) {
+        for (let feature of featureList) {
+          if (feature.name) {
+            this.genome.featureDB[feature.name.toUpperCase()] = feature;
+          }
+
+          if (feature.gene && feature.gene.name) {
+            this.genome.featureDB[feature.gene.name.toUpperCase()] = feature;
+          }
+        }
+      } // TODO -- filter by pixel size
+
+
+      getWGFeatures(allFeatures) {
+        const genome = this.genome;
+        const wgChromosomeNames = new Set(genome.wgChromosomeNames);
+        const wgFeatures = [];
+
+        for (let c of genome.wgChromosomeNames) {
+          const features = allFeatures[c];
+
+          if (features) {
+            for (let f of features) {
+              let queryChr = genome.getChromosomeName(f.chr);
+
+              if (wgChromosomeNames.has(queryChr)) {
+                const wg = Object.assign({}, f);
+                wg.chr = "all";
+                wg.start = genome.getGenomeCoordinate(f.chr, f.start);
+                wg.end = genome.getGenomeCoordinate(f.chr, f.end);
+                wg._f = f; // Don't draw exons in whole genome view
+
+                if (wg["exons"]) delete wg["exons"];
+                wgFeatures.push(wg);
+              }
+            }
+          }
+        }
+
+        wgFeatures.sort(function (a, b) {
+          return a.start - b.start;
+        });
+        return wgFeatures;
+      }
+
+    }
+
+    function packFeatures(features, maxRows) {
+      maxRows = maxRows || 1000;
+
+      if (features == null || features.length === 0) {
+        return;
+      } // Segregate by chromosome
+
+
+      const chrFeatureMap = {};
+      const chrs = [];
+
+      for (let feature of features) {
+        const chr = feature.chr;
+        let flist = chrFeatureMap[chr];
+
+        if (!flist) {
+          flist = [];
+          chrFeatureMap[chr] = flist;
+          chrs.push(chr);
+        }
+
+        flist.push(feature);
+      } // Loop through chrosomosomes and pack features;
+
+
+      for (let chr of chrs) {
+        pack(chrFeatureMap[chr], maxRows);
+      }
+    }
+    /**
+     * This function is used to apply properties normally added during parsing to  features supplied directly in the
+     * config as an array of objects.   At the moment the only application is bedpe type features.
+     * @param features
+     */
+
+
+    function fixFeatures(features, genome) {
+      if (!features || features.length === 0) return [];
+      const isBedPE = features[0].chr === undefined && features[0].chr1 !== undefined;
+
+      if (isBedPE) {
+        const interChrFeatures = [];
+
+        for (let feature of features) {
+          if (genome) {
+            feature.chr1 = genome.getChromosomeName(feature.chr1);
+            feature.chr2 = genome.getChromosomeName(feature.chr2);
+          } // Set total extent of feature
+
+
+          if (feature.chr1 === feature.chr2) {
+            feature.chr = feature.chr1;
+            feature.start = Math.min(feature.start1, feature.start2);
+            feature.end = Math.max(feature.end1, feature.end2);
+          } else {
+            interChrFeatures.push(feature);
+          }
+        } // Make copies of inter-chr features, one for each chromosome
+
+
+        for (let f1 of interChrFeatures) {
+          const f2 = Object.assign({
+            dup: true
+          }, f1);
+          features.push(f2);
+          f1.chr = f1.chr1;
+          f1.start = f1.start1;
+          f1.end = f1.end1;
+          f2.chr = f2.chr2;
+          f2.start = f2.start2;
+          f2.end = f2.end2;
+        }
+      } else if (genome) {
+        for (let feature of features) {
+          feature.chr = genome.getChromosomeName(feature.chr);
+        }
+      }
+
+      return features;
+    }
+
+    function mapProperties(features, mappings) {
+      let mappingKeys = Object.keys(mappings);
+      features.forEach(function (f) {
+        mappingKeys.forEach(function (key) {
+          f[key] = f[mappings[key]];
+        });
+      });
+    }
+
+    class BufferedReader {
+      constructor(config, contentLength, bufferSize) {
+        this.path = config.url;
+        this.bufferSize = bufferSize ? bufferSize : 512000;
+        this.range = {
+          start: -1,
+          size: -1
+        };
+        this.config = config;
+      }
+      /**
+       *
+       * @param requestedRange - byte rangeas {start, size}
+       * @param fulfill - function to receive result
+       * @param asUint8 - optional flag to return result as an UInt8Array
+       */
+
+
+      async dataViewForRange(requestedRange, asUint8) {
+        const hasData = this.data && this.range.start <= requestedRange.start && this.range.start + this.range.size >= requestedRange.start + requestedRange.size;
+
+        if (!hasData) {
+          let bufferSize; // If requested range size is specified, potentially expand buffer size
+
+          if (requestedRange.size) {
+            bufferSize = Math.max(this.bufferSize, requestedRange.size);
+          } else {
+            bufferSize = this.bufferSize;
+          }
+
+          const loadRange = {
+            start: requestedRange.start,
+            size: bufferSize
+          };
+          const arrayBuffer = await igvxhr.loadArrayBuffer(this.path, buildOptions(this.config, {
+            range: loadRange
+          }));
+          this.data = arrayBuffer;
+          this.range = loadRange;
+        }
+
+        const len = this.data.byteLength;
+        const bufferStart = requestedRange.start - this.range.start;
+        return asUint8 ? new Uint8Array(this.data, bufferStart, len - bufferStart) : new DataView(this.data, bufferStart, len - bufferStart);
+      }
+
+    }
+
+    function scoreShade(score, color) {
+      const alpha = Math.min(1, 0.11 + 0.89 * (score / 779));
+      return alpha.toString();
+    }
+
+    function parseAutoSQL(str) {
+      let table;
+      const fields = [];
+      let startDecoding = false;
+      const lines = str.trim().split(/\s*[\r\n]+\s*/g);
+
+      for (let line of lines) {
+        if (line.startsWith('table')) {
+          table = line.split(/\s+/)[1].trim();
+        } else if (line.startsWith('(')) {
+          startDecoding = true;
+        } else if (line.startsWith(')')) ; else if (startDecoding) {
+          if (line.length > 0) {
+            const idx = line.indexOf(';');
+            const tokens = line.substr(0, idx).split(/\s+/);
+            const description = line.substr(idx + 1).replace(/"/g, '').trim();
+            fields.push({
+              type: tokens[0],
+              name: tokens[1],
+              description: description
+            });
+          }
+        }
+      }
+
+      return {
+        table: table,
+        fields: fields
+      };
+    }
+
+    //table chromatinInteract
+
+    function getDecoder(definedFieldCount, fieldCount, autoSql) {
+      if (autoSql && 'chromatinInteract' === autoSql.table) {
+        return decodeInteract;
+      } else {
+        const standardFieldCount = definedFieldCount - 3;
+        return function (feature, tokens) {
+          if (standardFieldCount > 0) {
+            feature.name = tokens[0];
+          }
+
+          if (standardFieldCount > 1) {
+            feature.score = parseFloat(tokens[1]);
+          }
+
+          if (standardFieldCount > 2) {
+            feature.strand = tokens[2];
+          }
+
+          if (standardFieldCount > 3) {
+            feature.cdStart = parseInt(tokens[3]);
+          }
+
+          if (standardFieldCount > 4) {
+            feature.cdEnd = parseInt(tokens[4]);
+          }
+
+          if (standardFieldCount > 5) {
+            if (tokens[5] !== "." && tokens[5] !== "0" && tokens[5] !== "-1") {
+              const c = IGVColor.createColorString(tokens[5]);
+              feature.color = c.startsWith("rgb") ? c : undefined;
+            }
+          }
+
+          if (standardFieldCount > 8) {
+            const exonCount = parseInt(tokens[6]);
+            const exonSizes = tokens[7].split(',');
+            const exonStarts = tokens[8].split(',');
+            const exons = [];
+
+            for (let i = 0; i < exonCount; i++) {
+              const eStart = feature.start + parseInt(exonStarts[i]);
+              const eEnd = eStart + parseInt(exonSizes[i]);
+              exons.push({
+                start: eStart,
+                end: eEnd
+              });
+            }
+
+            feature.exons = exons;
+          }
+
+          if (autoSql) {
+            // TODO -- these should be equal, validate?  fieldCount-definedFieldCount, as.fields.length, tokens.length-3
+            const extraStart = definedFieldCount;
+
+            for (let i = extraStart; i < fieldCount; i++) {
+              if (i < autoSql.fields.length) {
+                const name = autoSql.fields[i].name;
+                const value = tokens[i - 3];
+                feature[name] = value;
+              }
+            }
+          }
+        };
+      }
+
+      function decodeInteract(feature, tokens) {
+        feature.chr1 = tokens[5];
+        feature.start1 = Number.parseInt(tokens[6]);
+        feature.end1 = Number.parseInt(tokens[7]);
+        feature.chr2 = tokens[10];
+        feature.start2 = Number.parseInt(tokens[11]);
+        feature.end2 = Number.parseInt(tokens[12]);
+        feature.name = tokens[0];
+        feature.score = Number.parseFloat(tokens[1]);
+        feature.value = Number.parseFloat(tokens[2]);
+        feature.color = tokens[4] === '.' ? undefined : tokens[4] === "0" ? "rgb(0,0,0)" : tokens[4];
+        return feature;
+      }
+    }
+
+    let BIGWIG_MAGIC_LTH = 0x888FFC26; // BigWig Magic Low to High
+
+    let BIGWIG_MAGIC_HTL = 0x26FC8F66; // BigWig Magic High to Low
+
+    let BIGBED_MAGIC_LTH = 0x8789F2EB; // BigBed Magic Low to High
+
+    let BIGBED_MAGIC_HTL = 0xEBF28987; // BigBed Magic High to Low
+
+    let BBFILE_HEADER_SIZE = 64;
+    let RPTREE_HEADER_SIZE = 48;
+    let RPTREE_NODE_LEAF_ITEM_SIZE = 32; // leaf item size
+
+    let RPTREE_NODE_CHILD_ITEM_SIZE = 24; // child item size
+
+    let BUFFER_SIZE = 512000; //  buffer
+
+    class BWReader {
+      constructor(config, genome) {
+        this.path = config.url;
+        this.genome = genome;
+        this.rpTreeCache = {};
+        this.config = config;
+      }
+
+      async readWGFeatures(bpPerPixel, windowFunction) {
+        await this.loadHeader();
+        const chrIdx1 = 0;
+        const chrIdx2 = this.chromTree.idToChrom.length - 1;
+        const chr1 = this.chromTree.idToChrom[chrIdx1];
+        const chr2 = this.chromTree.idToChrom[chrIdx2];
+        return this.readFeatures(chr1, 0, chr2, Number.MAX_VALUE, bpPerPixel, windowFunction);
+      }
+
+      async readFeatures(chr1, bpStart, chr2, bpEnd, bpPerPixel, windowFunction) {
+        await this.loadHeader();
+        const chrIdx1 = this.chromTree.chromToID[chr1];
+        const chrIdx2 = this.chromTree.chromToID[chr2];
+
+        if (chrIdx1 === undefined || chrIdx2 === undefined) {
+          return [];
+        }
+
+        let treeOffset;
+        let decodeFunction;
+
+        if (this.type === "bigwig") {
+          // Select a biwig "zoom level" appropriate for the current resolution.
+          const zoomLevelHeaders = await this.getZoomHeaders();
+          let zoomLevelHeader = bpPerPixel ? zoomLevelForScale$1(bpPerPixel, zoomLevelHeaders) : undefined;
+
+          if (zoomLevelHeader) {
+            treeOffset = zoomLevelHeader.indexOffset;
+            decodeFunction = decodeZoomData;
+          } else {
+            treeOffset = this.header.fullIndexOffset;
+            decodeFunction = decodeWigData;
+          }
+        } else {
+          // bigbed, zoom data is not currently used in igv for bed type features
+          treeOffset = this.header.fullIndexOffset;
+          decodeFunction = getBedDataDecoder.call(this);
+        } // Load the R Tree and fine leaf items
+
+
+        const rpTree = await this.loadRPTree(treeOffset);
+        const leafItems = await rpTree.findLeafItemsOverlapping(chrIdx1, bpStart, chrIdx2, bpEnd);
+
+        if (!leafItems || leafItems.length === 0) {
+          return [];
+        } else {
+          // Consolidate leaf items and get all data at once
+          let start = Number.MAX_VALUE;
+          let end = 0;
+
+          for (let item of leafItems) {
+            start = Math.min(start, item.dataOffset);
+            end = Math.max(end, item.dataOffset + item.dataSize);
+          }
+
+          const size = end - start;
+          const arrayBuffer = await igvxhr.loadArrayBuffer(this.config.url, buildOptions(this.config, {
+            range: {
+              start: start,
+              size: size
+            }
+          })); // Parse data and return features
+
+          const allFeatures = [];
+          const buffer = new Uint8Array(arrayBuffer);
+
+          for (let item of leafItems) {
+            const uint8Array = buffer.subarray(item.dataOffset - start, item.dataOffset + item.dataSize);
+            let plain;
+            const isCompressed = this.header.uncompressBuffSize > 0;
+
+            if (isCompressed) {
+              const inflate = new Zlib$1.Inflate(uint8Array);
+              plain = inflate.decompress();
+            } else {
+              plain = uint8Array;
+            }
+
+            decodeFunction.call(this, new DataView(plain.buffer), chrIdx1, bpStart, chrIdx2, bpEnd, allFeatures, this.chromTree.idToChrom, windowFunction);
+          }
+
+          allFeatures.sort(function (a, b) {
+            return a.start - b.start;
+          });
+          return allFeatures;
+        }
+      }
+
+      async getZoomHeaders() {
+        if (this.zoomLevelHeaders) {
+          return this.zoomLevelHeaders;
+        } else {
+          await this.loadHeader();
+          return this.zoomLevelHeaders;
+        }
+      }
+
+      async loadHeader() {
+        if (this.header) {
+          return this.header;
+        } else {
+          let data = await igvxhr.loadArrayBuffer(this.path, buildOptions(this.config, {
+            range: {
+              start: 0,
+              size: BBFILE_HEADER_SIZE
+            }
+          }));
+          let header; // Assume low-to-high unless proven otherwise
+
+          this.littleEndian = true;
+          let binaryParser = new BinaryParser(new DataView(data));
+          let magic = binaryParser.getUInt();
+
+          if (magic === BIGWIG_MAGIC_LTH) {
+            this.type = "bigwig";
+          } else if (magic === BIGBED_MAGIC_LTH) {
+            this.type = "bigbed";
+          } else {
+            //Try big endian order
+            this.littleEndian = false;
+            binaryParser.littleEndian = false;
+            binaryParser.position = 0;
+            let magic = binaryParser.getUInt();
+
+            if (magic === BIGWIG_MAGIC_HTL) {
+              this.type = "bigwig";
+            } else if (magic === BIGBED_MAGIC_HTL) {
+              this.type = "bigbed";
+            } else ;
+          } // Table 5  "Common header for bigwig and bigbed files"
+
+
+          header = {
+            bwVersion: binaryParser.getUShort(),
+            nZoomLevels: binaryParser.getUShort(),
+            chromTreeOffset: binaryParser.getLong(),
+            fullDataOffset: binaryParser.getLong(),
+            fullIndexOffset: binaryParser.getLong(),
+            fieldCount: binaryParser.getUShort(),
+            definedFieldCount: binaryParser.getUShort(),
+            autoSqlOffset: binaryParser.getLong(),
+            totalSummaryOffset: binaryParser.getLong(),
+            uncompressBuffSize: binaryParser.getInt(),
+            extensionOffset: binaryParser.getLong()
+          }; ///////////
+
+          const startOffset = BBFILE_HEADER_SIZE;
+          let range = {
+            start: startOffset,
+            size: header.fullDataOffset - startOffset + 5
+          };
+          data = await igvxhr.loadArrayBuffer(this.path, buildOptions(this.config, {
+            range: range
+          }));
+          const nZooms = header.nZoomLevels;
+          binaryParser = new BinaryParser(new DataView(data));
+          this.zoomLevelHeaders = [];
+          this.firstZoomDataOffset = Number.MAX_SAFE_INTEGER;
+
+          for (let i = 1; i <= nZooms; i++) {
+            const zoomNumber = nZooms - i;
+            const zlh = new ZoomLevelHeader(zoomNumber, binaryParser);
+            this.firstZoomDataOffset = Math.min(zlh.dataOffset, this.firstZoomDataOffset);
+            this.zoomLevelHeaders[zoomNumber] = zlh;
+          } // Autosql
+
+
+          if (header.autoSqlOffset > 0) {
+            binaryParser.position = header.autoSqlOffset - startOffset;
+            const autoSqlString = binaryParser.getString();
+
+            if (autoSqlString) {
+              this.autoSql = parseAutoSQL(autoSqlString);
+            }
+          } // Total summary
+
+
+          if (header.totalSummaryOffset > 0) {
+            binaryParser.position = header.totalSummaryOffset - startOffset;
+            this.totalSummary = new BWTotalSummary(binaryParser);
+          } // Chrom data index
+
+
+          if (header.chromTreeOffset > 0) {
+            binaryParser.position = header.chromTreeOffset - startOffset;
+            this.chromTree = new BPTree(binaryParser, startOffset, this.genome);
+          } else {
+            // TODO -- this is an error, not expected
+            throw "BigWig chromosome tree offset <= 0";
+          } //Finally total data count
+
+
+          binaryParser.position = header.fullDataOffset - startOffset;
+          header.dataCount = binaryParser.getInt(); ///////////
+
+          this.setDefaultVisibilityWindow(header);
+          this.header = header;
+          return this.header;
+        }
+      }
+
+      async loadRPTree(offset) {
+        let rpTree = this.rpTreeCache[offset];
+
+        if (rpTree) {
+          return rpTree;
+        } else {
+          rpTree = new RPTree(offset, this.config, this.littleEndian);
+          await rpTree.load();
+          this.rpTreeCache[offset] = rpTree;
+          return rpTree;
+        }
+      }
+
+      async getType() {
+        await this.loadHeader();
+        return this.type;
+      }
+
+      async getTrackType() {
+        await this.loadHeader();
+
+        if (this.type === "bigwig") {
+          return "wig";
+        } else {
+          return this.autoSql && this.autoSql.table === "chromatinInteract" ? "interact" : "annotation";
+        }
+      }
+
+      setDefaultVisibilityWindow(header) {
+        if (this.type === "bigwig") {
+          this.visibilityWindow = -1;
+        } else {
+          // bigbed
+          let genomeSize = this.genome ? this.genome.getGenomeLength() : 3088286401; // Estimate window size to return ~ 1,000 features, assuming even distribution across the genome
+
+          this.visibilityWindow = header.dataCount < 1000 ? -1 : 1000 * (genomeSize / header.dataCount);
+        }
+      }
+
+    }
+
+    class ZoomLevelHeader {
+      constructor(index, byteBuffer) {
+        this.index = index;
+        this.reductionLevel = byteBuffer.getInt();
+        this.reserved = byteBuffer.getInt();
+        this.dataOffset = byteBuffer.getLong();
+        this.indexOffset = byteBuffer.getLong();
+      }
+
+    }
+
+    class RPTree {
+      constructor(fileOffset, config, littleEndian) {
+        this.config = config;
+        this.fileOffset = fileOffset; // File offset to beginning of tree
+
+        this.path = config.url;
+        this.littleEndian = littleEndian;
+      }
+
+      async load() {
+        const rootNodeOffset = this.fileOffset + RPTREE_HEADER_SIZE;
+        const bufferedReader = new BufferedReader(this.config, BUFFER_SIZE);
+        this.rootNode = await this.readNode(rootNodeOffset, bufferedReader);
+        return this;
+      }
+
+      async readNode(filePosition, bufferedReader) {
+        let dataView = await bufferedReader.dataViewForRange({
+          start: filePosition,
+          size: 4
+        }, false);
+        let binaryParser = new BinaryParser(dataView, this.littleEndian);
+        const type = binaryParser.getByte();
+        const isLeaf = type === 1;
+        binaryParser.getByte();
+        const count = binaryParser.getUShort();
+        filePosition += 4;
+        let bytesRequired = count * (isLeaf ? RPTREE_NODE_LEAF_ITEM_SIZE : RPTREE_NODE_CHILD_ITEM_SIZE);
+        let range2 = {
+          start: filePosition,
+          size: bytesRequired
+        };
+        dataView = await bufferedReader.dataViewForRange(range2, false);
+        const items = new Array(count);
+        binaryParser = new BinaryParser(dataView);
+
+        if (isLeaf) {
+          for (let i = 0; i < count; i++) {
+            let item = {
+              isLeaf: true,
+              startChrom: binaryParser.getInt(),
+              startBase: binaryParser.getInt(),
+              endChrom: binaryParser.getInt(),
+              endBase: binaryParser.getInt(),
+              dataOffset: binaryParser.getLong(),
+              dataSize: binaryParser.getLong()
+            };
+            items[i] = item;
+          }
+
+          return new RPTreeNode(items);
+        } else {
+          // non-leaf
+          for (let i = 0; i < count; i++) {
+            let item = {
+              isLeaf: false,
+              startChrom: binaryParser.getInt(),
+              startBase: binaryParser.getInt(),
+              endChrom: binaryParser.getInt(),
+              endBase: binaryParser.getInt(),
+              childOffset: binaryParser.getLong()
+            };
+            items[i] = item;
+          }
+
+          return new RPTreeNode(items);
+        }
+      }
+
+      async findLeafItemsOverlapping(chrIdx1, startBase, chrIdx2, endBase) {
+        let self = this;
+        return new Promise(function (fulfill, reject) {
+          let leafItems = [],
+              processing = new Set(),
+              bufferedReader = new BufferedReader(self.config, BUFFER_SIZE);
+          processing.add(0); // Zero represents the root node
+
+          findLeafItems(self.rootNode, 0);
+
+          function findLeafItems(node, nodeId) {
+            if (overlaps(node, chrIdx1, startBase, chrIdx2, endBase)) {
+              let items = node.items;
+              items.forEach(function (item) {
+                if (overlaps(item, chrIdx1, startBase, chrIdx2, endBase)) {
+                  if (item.isLeaf) {
+                    leafItems.push(item);
+                  } else {
+                    if (item.childNode) {
+                      findLeafItems(item.childNode);
+                    } else {
+                      processing.add(item.childOffset); // Represent node to-be-loaded by its file position
+
+                      self.readNode(item.childOffset, bufferedReader).then(function (node) {
+                        item.childNode = node;
+                        findLeafItems(node, item.childOffset);
+                      }).catch(reject);
+                    }
+                  }
+                }
+              });
+            }
+
+            if (nodeId !== undefined) processing.delete(nodeId); // Wait until all nodes are processed
+
+            if (processing.size === 0) {
+              fulfill(leafItems);
+            }
+          }
+        });
+      }
+
+    }
+
+    class RPTreeNode {
+      constructor(items) {
+        this.items = items;
+        let minChromId = Number.MAX_SAFE_INTEGER,
+            maxChromId = 0,
+            minStartBase = Number.MAX_SAFE_INTEGER,
+            maxEndBase = 0,
+            i,
+            item;
+
+        for (i = 0; i < items.length; i++) {
+          item = items[i];
+          minChromId = Math.min(minChromId, item.startChrom);
+          maxChromId = Math.max(maxChromId, item.endChrom);
+          minStartBase = Math.min(minStartBase, item.startBase);
+          maxEndBase = Math.max(maxEndBase, item.endBase);
+        }
+
+        this.startChrom = minChromId;
+        this.endChrom = maxChromId;
+        this.startBase = minStartBase;
+        this.endBase = maxEndBase;
+      }
+
+    }
+
+    class BPTree {
+      constructor(binaryParser, startOffset, genome) {
+        let magic = binaryParser.getInt();
+        let blockSize = binaryParser.getInt();
+        let keySize = binaryParser.getInt();
+        let valSize = binaryParser.getInt();
+        let itemCount = binaryParser.getLong();
+        let reserved = binaryParser.getLong();
+        let chromToId = {};
+        let idToChrom = [];
+        this.header = {
+          magic: magic,
+          blockSize: blockSize,
+          keySize: keySize,
+          valSize: valSize,
+          itemCount: itemCount,
+          reserved: reserved
+        };
+        this.chromToID = chromToId;
+        this.idToChrom = idToChrom; // Recursively walk tree to populate dictionary
+
+        readTreeNode(binaryParser, -1);
+
+        function readTreeNode(byteBuffer, offset) {
+          if (offset >= 0) byteBuffer.position = offset;
+          let type = byteBuffer.getByte();
+              byteBuffer.getByte();
+              let count = byteBuffer.getUShort(),
+              i,
+              key,
+              chromId,
+              childOffset,
+              bufferOffset,
+              currOffset;
+
+          if (type === 1) {
+            for (i = 0; i < count; i++) {
+              key = byteBuffer.getFixedLengthTrimmedString(keySize);
+              chromId = byteBuffer.getInt();
+              byteBuffer.getInt();
+              if (genome) key = genome.getChromosomeName(key); // Translate to canonical chr name
+
+              chromToId[key] = chromId;
+              idToChrom[chromId] = key;
+            }
+          } else {
+            // non-leaf
+            for (i = 0; i < count; i++) {
+              key = byteBuffer.getFixedLengthTrimmedString(keySize);
+              childOffset = byteBuffer.getLong();
+              bufferOffset = childOffset - startOffset;
+              currOffset = byteBuffer.position;
+              readTreeNode(byteBuffer, bufferOffset);
+              byteBuffer.position = currOffset;
+            }
+          }
+        }
+      }
+
+    }
+    /**
+     * Return true if {chrIdx1:startBase-chrIdx2:endBase} overlaps item's interval
+     * @returns {boolean}
+     */
+
+
+    function overlaps(item, chrIdx1, startBase, chrIdx2, endBase) {
+      if (!item) {
+        return false;
+      }
+
+      return (chrIdx2 > item.startChrom || chrIdx2 === item.startChrom && endBase >= item.startBase) && (chrIdx1 < item.endChrom || chrIdx1 === item.endChrom && startBase <= item.endBase);
+    }
+
+    class BWTotalSummary {
+      constructor(byteBuffer) {
+        if (byteBuffer) {
+          this.basesCovered = byteBuffer.getLong();
+          this.minVal = byteBuffer.getDouble();
+          this.maxVal = byteBuffer.getDouble();
+          this.sumData = byteBuffer.getDouble();
+          this.sumSquares = byteBuffer.getDouble();
+          computeStats.call(this);
+        } else {
+          this.basesCovered = 0;
+          this.minVal = 0;
+          this.maxVal = 0;
+          this.sumData = 0;
+          this.sumSquares = 0;
+          this.mean = 0;
+          this.stddev = 0;
+        }
+      }
+
+    }
+
+    function computeStats() {
+      let n = this.basesCovered;
+
+      if (n > 0) {
+        this.mean = this.sumData / n;
+        this.stddev = Math.sqrt(this.sumSquares / (n - 1));
+        let min = this.minVal < 0 ? this.mean - 2 * this.stddev : 0,
+            max = this.maxVal > 0 ? this.mean + 2 * this.stddev : 0;
+        this.defaultRange = {
+          min: min,
+          max: max
+        };
+      }
+    }
+
+    function zoomLevelForScale$1(bpPerPixel, zoomLevelHeaders) {
+      let level;
+
+      for (let i = 0; i < zoomLevelHeaders.length; i++) {
+        const zl = zoomLevelHeaders[i];
+
+        if (zl.reductionLevel < bpPerPixel) {
+          level = zl;
+          break;
+        }
+      }
+
+      return level;
+    }
+
+    function decodeWigData(data, chrIdx1, bpStart, chrIdx2, bpEnd, featureArray, chrDict) {
+      const binaryParser = new BinaryParser(data);
+      const chromId = binaryParser.getInt();
+      let chromStart = binaryParser.getInt();
+      let chromEnd = binaryParser.getInt();
+      const itemStep = binaryParser.getInt();
+      const itemSpan = binaryParser.getInt();
+      const type = binaryParser.getByte();
+      binaryParser.getByte();
+      let itemCount = binaryParser.getUShort();
+
+      if (chromId >= chrIdx1 && chromId <= chrIdx2) {
+        while (itemCount-- > 0) {
+          let value;
+
+          switch (type) {
+            case 1:
+              chromStart = binaryParser.getInt();
+              chromEnd = binaryParser.getInt();
+              value = binaryParser.getFloat();
+              break;
+
+            case 2:
+              chromStart = binaryParser.getInt();
+              value = binaryParser.getFloat();
+              chromEnd = chromStart + itemSpan;
+              break;
+
+            case 3:
+              // Fixed step
+              value = binaryParser.getFloat();
+              chromEnd = chromStart + itemSpan;
+              chromStart += itemStep;
+              break;
+          }
+
+          if (chromId < chrIdx1 || chromId === chrIdx1 && chromEnd < bpStart) continue;else if (chromId > chrIdx2 || chromId === chrIdx2 && chromStart >= bpEnd) break;
+
+          if (Number.isFinite(value)) {
+            const chr = chrDict[chromId];
+            featureArray.push({
+              chr: chr,
+              start: chromStart,
+              end: chromEnd,
+              value: value
+            });
+          }
+        }
+      }
+    }
+
+    function getBedDataDecoder() {
+      const minSize = 3 * 4 + 1; // Minimum # of bytes required for a bed record
+
+      const decoder = getDecoder(this.header.definedFieldCount, this.header.fieldCount, this.autoSql);
+      return function (data, chrIdx1, bpStart, chrIdx2, bpEnd, featureArray, chrDict) {
+        const binaryParser = new BinaryParser(data);
+
+        while (binaryParser.remLength() >= minSize) {
+          const chromId = binaryParser.getInt();
+          const chr = chrDict[chromId];
+          const chromStart = binaryParser.getInt();
+          const chromEnd = binaryParser.getInt();
+          const rest = binaryParser.getString();
+          if (chromId < chrIdx1 || chromId === chrIdx1 && chromEnd < bpStart) continue;else if (chromId > chrIdx2 || chromId === chrIdx2 && chromStart >= bpEnd) break;
+
+          if (chromEnd > 0) {
+            const feature = {
+              chr: chr,
+              start: chromStart,
+              end: chromEnd
+            };
+            featureArray.push(feature);
+            const tokens = rest.split("\t");
+            decoder(feature, tokens);
+          }
+        }
+      };
+    }
+
+    function decodeZoomData(data, chrIdx1, bpStart, chrIdx2, bpEnd, featureArray, chrDict, windowFunction) {
+      const binaryParser = new BinaryParser(data);
+      const minSize = 8 * 4; // Minimum # of bytes required for a zoom record
+
+      while (binaryParser.remLength() >= minSize) {
+        const chromId = binaryParser.getInt();
+        const chr = chrDict[chromId];
+        const chromStart = binaryParser.getInt();
+        const chromEnd = binaryParser.getInt();
+        const validCount = binaryParser.getInt();
+        const minVal = binaryParser.getFloat();
+        const maxVal = binaryParser.getFloat();
+        const sumData = binaryParser.getFloat();
+        binaryParser.getFloat();
+        let value;
+
+        switch (windowFunction) {
+          case "min":
+            value = minVal;
+            break;
+
+          case "max":
+            value = maxVal;
+            break;
+
+          default:
+            value = validCount === 0 ? 0 : sumData / validCount;
+        }
+
+        if (chromId < chrIdx1 || chromId === chrIdx1 && chromEnd < bpStart) continue;else if (chromId > chrIdx2 || chromId === chrIdx2 && chromStart >= bpEnd) break;
+
+        if (Number.isFinite(value)) {
+          featureArray.push({
+            chr: chr,
+            start: chromStart,
+            end: chromEnd,
+            value: value
+          });
+        }
+      }
+    }
+
+    /*
+     * The MIT License (MIT)
+     *
+     * Copyright (c) 2014 Broad Institute
+     *
+     * Permission is hereby granted, free of charge, to any person obtaining a copy
+     * of this software and associated documentation files (the "Software"), to deal
+     * in the Software without restriction, including without limitation the rights
+     * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+     * copies of the Software, and to permit persons to whom the Software is
+     * furnished to do so, subject to the following conditions:
+     *
+     * The above copyright notice and this permission notice shall be included in
+     * all copies or substantial portions of the Software.
+     *
+     *
+     * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+     * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+     * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+     * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+     * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+     * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+     * THE SOFTWARE.
+     */
+
+    class BWSource {
+      constructor(config, genome) {
+        this.reader = new BWReader(config, genome);
+        this.genome = genome;
+        this.format = config.format || "bigwig";
+        this.wgValues = {};
+      }
+
+      async getFeatures({
+        chr,
+        start,
+        end,
+        bpPerPixel,
+        windowFunction
+      }) {
+        const features = chr.toLowerCase() === "all" ? await this.getWGValues(windowFunction) : await this.reader.readFeatures(chr, start, chr, end, bpPerPixel, windowFunction);
+        const isBigWig = this.reader.type === "bigwig";
+
+        if (!isBigWig) {
+          pack(features);
+        }
+
+        return features;
+      }
+
+      async getHeader() {
+        return this.reader.loadHeader();
+      }
+
+      getDefaultRange() {
+        if (this.reader.totalSummary !== undefined) {
+          return this.reader.totalSummary.defaultRange;
+        } else {
+          return undefined;
+        }
+      }
+
+      async defaultVisibilityWindow() {
+        return this.reader.defaultVisibilityWindow;
+      }
+
+      async getWGValues(windowFunction) {
+        const nominalScreenWidth = 1000; // This doesn't need to be precise
+
+        const genome = this.genome;
+
+        if (this.wgValues[windowFunction]) {
+          return this.wgValues[windowFunction];
+        } else {
+          const bpPerPixel = genome.getGenomeLength() / nominalScreenWidth;
+          const features = await this.reader.readWGFeatures(bpPerPixel, windowFunction);
+          let wgValues = [];
+
+          for (let f of features) {
+            const chr = f.chr;
+            const offset = genome.getCumulativeOffset(chr);
+            const wgFeature = Object.assign({}, f);
+            wgFeature.chr = "all";
+            wgFeature.start = offset + f.start;
+            wgFeature.end = offset + f.end;
+            wgValues.push(wgFeature);
+          }
+
+          this.wgValues[windowFunction] = wgValues;
+          return wgValues;
+        }
+      }
+
+      supportsWholeGenome() {
+        return this.reader.type === "bigwig" || this.defaultVisibilityWindow() <= 0;
+      }
+
+      async trackType() {
+        return this.reader.getTrackType();
+      }
+
+    }
+
+    const GZIP_FLAG = 0x1;
+
+    class TDFReader {
+      constructor(config, genome) {
+        this.config = config;
+        this.genome = genome;
+        this.path = config.url;
+        this.groupCache = {};
+        this.datasetCache = {};
+      }
+
+      async readHeader() {
+        if (this.magic !== undefined) {
+          return this; // Already read
+        }
+
+        let data = await igvxhr.loadArrayBuffer(this.path, buildOptions(this.config, {
+          range: {
+            start: 0,
+            size: 64000
+          }
+        }));
+        let binaryParser = new BinaryParser(new DataView(data));
+        this.magic = binaryParser.getInt();
+        this.version = binaryParser.getInt();
+        this.indexPos = binaryParser.getLong();
+        this.indexSize = binaryParser.getInt();
+        binaryParser.getInt();
+
+        if (this.version >= 2) {
+          let nWindowFunctions = binaryParser.getInt();
+          this.windowFunctions = [];
+
+          while (nWindowFunctions-- > 0) {
+            this.windowFunctions.push(binaryParser.getString());
+          }
+        }
+
+        this.trackType = binaryParser.getString();
+        this.trackLine = binaryParser.getString();
+        let nTracks = binaryParser.getInt();
+        this.trackNames = [];
+
+        while (nTracks-- > 0) {
+          this.trackNames.push(binaryParser.getString());
+        }
+
+        this.genomeID = binaryParser.getString();
+        this.flags = binaryParser.getInt();
+        this.compressed = (this.flags & GZIP_FLAG) !== 0; // Now read index
+
+        data = await igvxhr.loadArrayBuffer(this.path, buildOptions(this.config, {
+          range: {
+            start: this.indexPos,
+            size: this.indexSize
+          }
+        }));
+        binaryParser = new BinaryParser(new DataView(data));
+        this.datasetIndex = {};
+        let nEntries = binaryParser.getInt();
+
+        while (nEntries-- > 0) {
+          const name = binaryParser.getString();
+          const pos = binaryParser.getLong();
+          const size = binaryParser.getInt();
+          this.datasetIndex[name] = {
+            position: pos,
+            size: size
+          };
+        }
+
+        this.groupIndex = {};
+        nEntries = binaryParser.getInt();
+
+        while (nEntries-- > 0) {
+          const name = binaryParser.getString();
+          const pos = binaryParser.getLong();
+          const size = binaryParser.getInt();
+          this.groupIndex[name] = {
+            position: pos,
+            size: size
+          };
+        }
+
+        return this;
+      }
+
+      async readDataset(chr, windowFunction, zoom) {
+        const key = chr + "_" + windowFunction + "_" + zoom;
+
+        if (this.datasetCache[key]) {
+          return this.datasetCache[key];
+        } else {
+          await this.readHeader();
+          const wf = this.version < 2 ? "" : "/" + windowFunction;
+          const zoomString = chr.toLowerCase() === "all" || zoom === undefined ? "0" : zoom.toString();
+          let dsName;
+
+          if (windowFunction === "raw") {
+            dsName = "/" + chr + "/raw";
+          } else {
+            dsName = "/" + chr + "/z" + zoomString + wf;
+          }
+
+          const indexEntry = this.datasetIndex[dsName];
+
+          if (indexEntry === undefined) {
+            return undefined;
+          }
+
+          const data = await igvxhr.loadArrayBuffer(this.path, buildOptions(this.config, {
+            range: {
+              start: indexEntry.position,
+              size: indexEntry.size
+            }
+          }));
+
+          if (!data) {
+            return undefined;
+          }
+
+          const binaryParser = new BinaryParser(new DataView(data));
+          let nAttributes = binaryParser.getInt();
+          const attributes = {};
+
+          while (nAttributes-- > 0) {
+            attributes[binaryParser.getString()] = binaryParser.getString();
+          }
+
+          const dataType = binaryParser.getString();
+          const tileWidth = binaryParser.getFloat();
+          let nTiles = binaryParser.getInt();
+          const tiles = [];
+
+          while (nTiles-- > 0) {
+            tiles.push({
+              position: binaryParser.getLong(),
+              size: binaryParser.getInt()
+            });
+          }
+
+          const dataset = {
+            name: dsName,
+            attributes: attributes,
+            dataType: dataType,
+            tileWidth: tileWidth,
+            tiles: tiles
+          };
+          this.datasetCache[key] = dataset;
+          return dataset;
+        }
+      }
+
+      async readRootGroup() {
+        const genome = this.genome;
+        const rootGroup = this.groupCache["/"];
+
+        if (rootGroup) {
+          return rootGroup;
+        } else {
+          const group = await this.readGroup("/");
+          const names = group["chromosomes"];
+          const maxZoomString = group["maxZoom"]; // Now parse out interesting attributes.
+
+          if (maxZoomString) {
+            this.maxZoom = Number(maxZoomString);
+          }
+
+          const totalCountString = group["totalCount"];
+
+          if (totalCountString) {
+            group.totalCount = Number.parseFloat(totalCountString);
+          } // Chromosome names
+
+
+          const chrAliasTable = {};
+
+          if (names) {
+            names.split(",").forEach(function (chr) {
+              const canonicalName = genome.getChromosomeName(chr);
+              chrAliasTable[canonicalName] = chr;
+            });
+          }
+
+          this.chrAliasTable = chrAliasTable;
+          this.groupCache["/"] = group;
+          return group;
+        }
+      }
+
+      async readGroup(name) {
+        const group = this.groupCache[name];
+
+        if (group) {
+          return group;
+        } else {
+          await this.readHeader();
+          const indexEntry = this.groupIndex[name];
+
+          if (indexEntry === undefined) {
+            return undefined;
+          }
+
+          const data = await igvxhr.loadArrayBuffer(this.path, buildOptions(this.config, {
+            range: {
+              start: indexEntry.position,
+              size: indexEntry.size
+            }
+          }));
+
+          if (!data) {
+            return undefined;
+          }
+
+          const binaryParser = new BinaryParser(new DataView(data));
+          const group = {
+            name: name
+          };
+          let nAttributes = binaryParser.getInt();
+
+          while (nAttributes-- > 0) {
+            const key = binaryParser.getString();
+            const value = binaryParser.getString();
+            group[key] = value;
+          }
+
+          this.groupCache[name] = group;
+          return group;
+        }
+      }
+
+      async readTiles(tileIndeces, nTracks) {
+        tileIndeces.sort(function (a, b) {
+          return a.position - b.position;
+        });
+        tileIndeces = tileIndeces.filter(function (idx) {
+          return idx.size > 0;
+        });
+
+        if (tileIndeces.length === 0) {
+          return Promise.resolve([]);
+        }
+
+        const firstEntry = tileIndeces[0];
+        const lastEntry = tileIndeces[tileIndeces.length - 1];
+        const position = firstEntry.position;
+        const size = lastEntry.position + lastEntry.size - position;
+        const data = await igvxhr.loadArrayBuffer(this.path, buildOptions(this.config, {
+          range: {
+            start: position,
+            size: size
+          }
+        }));
+        const tiles = []; // Loop through and decode tiles
+
+        for (let indexEntry of tileIndeces) {
+          const start = indexEntry.position - position;
+          const size = indexEntry.size;
+
+          if (size > 0) {
+            let tileData;
+
+            if (this.compressed) {
+              const inflate = new Zlib$1.Inflate(new Uint8Array(data, start, size));
+              const plain = inflate.decompress();
+              tileData = plain.buffer;
+            } else {
+              tileData = data.slice(start, start + size);
+            }
+
+            const binaryParser = new BinaryParser(new DataView(tileData));
+            const type = binaryParser.getString();
+            let tile;
+
+            switch (type) {
+              case "fixedStep":
+                tile = createFixedStep(binaryParser, nTracks);
+                break;
+
+              case "variableStep":
+                tile = createVariableStep(binaryParser, nTracks);
+                break;
+
+              case "bed":
+              case "bedWithName":
+                tile = createBed(binaryParser, nTracks, type);
+                break;
+
+              default:
+                throw "Unknown tile type: " + type;
+            }
+
+            tiles.push(tile);
+          }
+        }
+
+        return tiles;
+      }
+
+      async readTile(indexEntry, nTracks) {
+        let data = await igvxhr.loadArrayBuffer(this.path, buildOptions(this.config, {
+          range: {
+            start: indexEntry.position,
+            size: indexEntry.size
+          }
+        }));
+
+        if (this.compressed) {
+          const inflate = new Zlib$1.Inflate(new Uint8Array(data));
+          const plain = inflate.decompress();
+          data = plain.buffer;
+        }
+
+        const binaryParser = new BinaryParser(new DataView(data));
+        const type = binaryParser.getString();
+
+        switch (type) {
+          case "fixedStep":
+            return createFixedStep(binaryParser, nTracks);
+
+          case "variableStep":
+            return createVariableStep(binaryParser, nTracks);
+
+          case "bed":
+          case "bedWithName":
+            return createBed(binaryParser, nTracks, type);
+
+          default:
+            throw "Unknown tile type: " + type;
+        }
+      }
+
+    }
+
+    function createFixedStep(binaryParser, nTracks) {
+      const nPositions = binaryParser.getInt();
+      const start = binaryParser.getInt();
+      const span = binaryParser.getFloat();
+      const data = [];
+      let nt = nTracks;
+
+      while (nt-- > 0) {
+        let np = nPositions;
+        const dtrack = [];
+
+        while (np-- > 0) {
+          dtrack.push(binaryParser.getFloat());
+        }
+
+        data.push(dtrack);
+      }
+
+      return {
+        type: "fixedStep",
+        start: start,
+        span: span,
+        data: data,
+        nTracks: nTracks,
+        nPositions: nPositions
+      };
+    }
+
+    function createVariableStep(binaryParser, nTracks) {
+      const tileStart = binaryParser.getInt();
+      const span = binaryParser.getFloat();
+      const nPositions = binaryParser.getInt();
+      const start = [];
+      let np = nPositions;
+
+      while (np-- > 0) {
+        start.push(binaryParser.getInt());
+      }
+
+      binaryParser.getInt(); // # of samples, ignored but should === nTracks
+
+      const data = [];
+      let nt = nTracks;
+
+      while (nt-- > 0) {
+        np = nPositions;
+        const dtrack = [];
+
+        while (np-- > 0) {
+          dtrack.push(binaryParser.getFloat());
+        }
+
+        data.push(dtrack);
+      }
+
+      return {
+        type: "variableStep",
+        tileStart: tileStart,
+        span: span,
+        start: start,
+        data: data,
+        nTracks: nTracks,
+        nPositions: nPositions
+      };
+    }
+
+    function createBed(binaryParser, nTracks, type) {
+      const nPositions = binaryParser.getInt();
+      let n = nPositions;
+      const start = [];
+
+      while (n-- > 0) {
+        start.push(binaryParser.getInt());
+      }
+
+      n = nPositions;
+      const end = [];
+
+      while (n-- > 0) {
+        end.push(binaryParser.getInt());
+      }
+
+      binaryParser.getInt(); // # of samples, ignored but should === nTracks
+
+      const data = [];
+      let nt = nTracks;
+
+      while (nt-- > 0) {
+        let np = nPositions;
+        const dtrack = [];
+
+        while (np-- > 0) {
+          dtrack.push(binaryParser.getFloat());
+        }
+
+        data.push(dtrack);
+      }
+
+      if (type === "bedWithName") {
+        n = nPositions;
+        const name = [];
+
+        while (n-- > 0) {
+          name.push(binaryParser.getString());
+        }
+      }
+
+      return {
+        type: type,
+        start: start,
+        end: end,
+        data: data,
+        nTracks: nTracks,
+        nPositions: nPositions
+      };
+    }
+
+    /*
+     * The MIT License (MIT)
+     *
+     * Copyright (c) 2016 University of California San Diego
+     * Author: Jim Robinson
+     *
+     * Permission is hereby granted, free of charge, to any person obtaining a copy
+     * of this software and associated documentation files (the "Software"), to deal
+     * in the Software without restriction, including without limitation the rights
+     * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+     * copies of the Software, and to permit persons to whom the Software is
+     * furnished to do so, subject to the following conditions:
+     *
+     * The above copyright notice and this permission notice shall be included in
+     * all copies or substantial portions of the Software.
+     *
+     *
+     * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+     * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+     * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+     * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+     * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+     * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+     * THE SOFTWARE.
+     */
+
+    class TDFSource {
+      constructor(config, genome) {
+        this.genome = genome;
+        this.windowFunction = config.windowFunction || "mean";
+        this.reader = new TDFReader(config, genome);
+      }
+
+      async getFeatures({
+        chr,
+        start,
+        end,
+        bpPerPixel
+      }) {
+        const genomicInterval = new GenomicInterval(chr, start, end);
+        const genome = this.genome;
+
+        if (!this.rootGroup) {
+          this.rootGroup = await this.reader.readRootGroup();
+
+          if (!this.normalizationFactor) {
+            const totalCount = this.rootGroup.totalCount;
+
+            if (totalCount) {
+              this.normalizationFactor = 1.0e6 / totalCount;
+            }
+          }
+        }
+
+        if (chr.toLowerCase() === "all") {
+          return []; // Whole genome view not yet supported
+        }
+
+        genomicInterval.bpPerPixel = bpPerPixel;
+        const zoom = zoomLevelForScale(chr, bpPerPixel, genome);
+        let queryChr = this.reader.chrAliasTable[chr];
+        let maxZoom = this.reader.maxZoom;
+        if (queryChr === undefined) queryChr = chr;
+        if (maxZoom === undefined) maxZoom = -1;
+        const wf = zoom > maxZoom ? "raw" : this.windowFunction;
+        const dataset = await this.reader.readDataset(queryChr, wf, zoom);
+
+        if (dataset == null) {
+          return [];
+        }
+
+        const tileWidth = dataset.tileWidth;
+        const startTile = Math.floor(start / tileWidth);
+        const endTile = Math.floor(end / tileWidth);
+        const NTRACKS = 1; // TODO read this
+
+        const tiles = await this.reader.readTiles(dataset.tiles.slice(startTile, endTile + 1), NTRACKS);
+        const features = [];
+
+        for (let tile of tiles) {
+          switch (tile.type) {
+            case "bed":
+              decodeBedTile(tile, chr, start, end, bpPerPixel, features);
+              break;
+
+            case "variableStep":
+              decodeVaryTile(tile, chr, start, end, bpPerPixel, features);
+              break;
+
+            case "fixedStep":
+              decodeFixedTile(tile, chr, start, end, bpPerPixel, features);
+              break;
+
+            default:
+              throw "Unknown tile type: " + tile.type;
+          }
+        }
+
+        features.sort(function (a, b) {
+          return a.start - b.start;
+        });
+        return features;
+      }
+
+      supportsWholeGenome() {
+        return false;
+      }
+
+    }
+
+    function decodeBedTile(tile, chr, bpStart, bpEnd, bpPerPixel, features) {
+      const nPositions = tile.nPositions;
+      const starts = tile.start;
+      const ends = tile.end;
+      const data = tile.data[0]; // Single track for now
+
+      for (let i = 0; i < nPositions; i++) {
+        const s = starts[i];
+        const e = ends[i];
+        if (e < bpStart) continue;
+        if (s > bpEnd) break;
+        features.push({
+          chr: chr,
+          start: s,
+          end: e,
+          value: data[i]
+        });
+      }
+    }
+
+    function decodeVaryTile(tile, chr, bpStart, bpEnd, bpPerPixel, features) {
+      const nPositions = tile.nPositions;
+      const starts = tile.start;
+      const span = tile.span;
+      const data = tile.data[0]; // Single track for now
+
+      for (let i = 0; i < nPositions; i++) {
+        const s = starts[i];
+        const e = s + span;
+        if (e < bpStart) continue;
+        if (s > bpEnd) break;
+        features.push({
+          chr: chr,
+          start: s,
+          end: e,
+          value: data[i]
+        });
+      }
+    }
+
+    function decodeFixedTile(tile, chr, bpStart, bpEnd, bpPerPixel, features) {
+      const nPositions = tile.nPositions;
+      let s = tile.start;
+      const span = tile.span;
+      const data = tile.data[0]; // Single track for now
+
+      for (let i = 0; i < nPositions; i++) {
+        const e = s + span;
+        if (s > bpEnd) break;
+
+        if (e >= bpStart) {
+          if (!Number.isNaN(data[i])) {
+            features.push({
+              chr: chr,
+              start: s,
+              end: e,
+              value: data[i]
+            });
+          }
+        }
+
+        s = e;
+      }
+    }
+
+    var log2 = Math.log(2);
+
+    function zoomLevelForScale(chr, bpPerPixel, genome) {
+      // Convert bpPerPixel to IGV "zoom" level.   This is a bit convoluted,  IGV computes zoom levels assuming
+      // display in a 700 pixel window.  The fully zoomed out view of a chromosome is zoom level "0".
+      // Zoom level 1 is magnified 2X,  and so forth
+      var chrSize = genome.getChromosome(chr).bpLength;
+      return Math.ceil(Math.log(Math.max(0, chrSize / (bpPerPixel * 700))) / log2);
+    }
+
+    /*
+     * The MIT License (MIT)
+     *
+     * Copyright (c) 2014-2015 Broad Institute
+     *
+     * Permission is hereby granted, free of charge, to any person obtaining a copy
+     * of this software and associated documentation files (the "Software"), to deal
+     * in the Software without restriction, including without limitation the rights
+     * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+     * copies of the Software, and to permit persons to whom the Software is
+     * furnished to do so, subject to the following conditions:
+     *
+     * The above copyright notice and this permission notice shall be included in
+     * all copies or substantial portions of the Software.
+     *
+     *
+     * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+     * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+     * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+     * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+     * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+     * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+     * THE SOFTWARE.
+     */
+
+    function FeatureSource(config, genome) {
+      const format = config.format ? config.format.toLowerCase() : undefined;
+
+      if ('bigwig' === format || 'bigbed' === format || 'bb' === format) {
+        return new BWSource(config, genome);
+      } else if ("tdf" === format) {
+        return new TDFSource(config, genome);
+      } else {
+        return new TextFeatureSource(config, genome);
+      }
+    }
+
+    const GtexUtils = {
+      getTissueInfo: function (datasetId, baseURL) {
+        datasetId = datasetId || 'gtex_v8';
+        baseURL = baseURL || 'https://gtexportal.org/rest/v1';
+        let url = baseURL + '/dataset/tissueInfo?datasetId=' + datasetId;
+        return igvxhr.loadJson(url, {});
+      },
+      //https://gtexportal.org/rest/v1/association/singleTissueEqtlByLocation?chromosome=7&start=98358766&end=101523798&tissueName=Liver&datasetId=gtex_v7
+      //https://gtexportal.org/rest/v1/association/singleTissueEqtlByLocation?chromosome=7&start=98358766&end=101523798&tissueSiteDetailId=Liver&datasetId=gtex_v8
+      trackConfiguration: function (tissueSummary, baseURL) {
+        baseURL = baseURL || 'https://gtexportal.org/rest/v1';
+        return {
+          type: "eqtl",
+          sourceType: "gtex-ws",
+          url: baseURL + '/association/singleTissueEqtlByLocation',
+          tissueSiteDetailId: tissueSummary.tissueSiteDetailId,
+          name: tissueSummary.tissueSiteDetailId.split('_').join(' '),
+          visibilityWindow: 250000
+        };
+      }
+    };
+
+    /*
+     * The MIT License (MIT)
+     *
+     * Copyright (c) 2014 Broad Institute
+     *
+     * Permission is hereby granted, free of charge, to any person obtaining a copy
+     * of this software and associated documentation files (the "Software"), to deal
+     * in the Software without restriction, including without limitation the rights
+     * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+     * copies of the Software, and to permit persons to whom the Software is
+     * furnished to do so, subject to the following conditions:
+     *
+     * The above copyright notice and this permission notice shall be included in
+     * all copies or substantial portions of the Software.
+     *
+     *
+     * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+     * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+     * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+     * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+     * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+     * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+     * THE SOFTWARE.
+     */
+    let JUNCTION_MOTIF_PALETTE = new PaletteColorTable("Dark2"); // Lock in color-to-motif mapping so it's independent of data loading order. This list may not include all possible
+    // motif values as this varies depending on the RNA-seq pipeline. The current list is based on STAR v2.4 docs.
+
+    const someMotifValues = ['GT/AG', 'CT/AC', 'GC/AG', 'CT/GC', 'AT/AC', 'GT/AT', 'non-canonical'];
+    someMotifValues.forEach(motif => {
+      JUNCTION_MOTIF_PALETTE.getColor(motif);
+    }); // rendering context with values that only need to be computed once per render, rather than for each splice junction
+
+    const junctionRenderingContext = {};
+
+    class FeatureTrack extends TrackBase {
+      constructor(config, browser) {
+        super(config, browser);
+      }
+
+      init(config) {
+        super.init(config);
+        this.type = config.type || "annotation"; // Set maxRows -- protects against pathological feature packing cases (# of rows of overlapping feaures)
+
+        this.maxRows = config.maxRows === undefined ? 1000 : config.maxRows;
+        this.displayMode = config.displayMode || "EXPANDED"; // COLLAPSED | EXPANDED | SQUISHED
+
+        this.labelDisplayMode = config.labelDisplayMode;
+
+        if (config._featureSource) {
+          this.featureSource = config._featureSource;
+          delete config._featureSource;
+        } else {
+          this.featureSource = config.featureSource ? config.featureSource : FeatureSource(config, this.browser.genome);
+        } // Set default heights
+
+
+        this.autoHeight = config.autoHeight;
+        this.margin = config.margin === undefined ? 10 : config.margin;
+        this.featureHeight = config.featureHeight || 14;
+
+        if ("FusionJuncSpan" === config.type) {
+          this.squishedRowHeight = config.squishedRowHeight || 50;
+          this.expandedRowHeight = config.expandedRowHeight || 50;
+          this.height = config.height || this.margin + 2 * this.expandedRowHeight;
+        } else if ('snp' === config.type) {
+          this.expandedRowHeight = config.expandedRowHeight || 10;
+          this.squishedRowHeight = config.squishedRowHeight || 5;
+          this.height = config.height || 30;
+        } else {
+          this.squishedRowHeight = config.squishedRowHeight || 15;
+          this.expandedRowHeight = config.expandedRowHeight || 30;
+          this.height = config.height || this.margin + 2 * this.expandedRowHeight;
+        }
+
+        if (this.height === undefined || !this.height) {
+          this.height = 100;
+        } //set defaults
+
+
+        if ('spliceJunctions' === config.type && config.colorByNumReadsThreshold === undefined) {
+          config.colorByNumReadsThreshold = 5;
+        } // Set the render function.  This can optionally be passed in the config
+
+
+        if (config.render) {
+          this.render = config.render;
+        } else if ("FusionJuncSpan" === config.type) {
+          this.render = renderFusionJuncSpan;
+        } else if ('spliceJunctions' === config.type) {
+          this.render = renderJunctions;
+          this.displayMode = "COLLAPSED"; // needed for this.clickedFeatures(..) to work
+        } else if ('snp' === config.type) {
+          this.render = renderSnp; // colors ordered based on priority least to greatest
+
+          this.snpColors = ['rgb(0,0,0)', 'rgb(0,0,255)', 'rgb(0,255,0)', 'rgb(255,0,0)'];
+          this.colorBy = 'function';
+        } else {
+          this.render = renderFeature;
+          this.arrowSpacing = 30; // adjust label positions to make sure they're always visible
+
+          monitorTrackDrag(this);
+        } //UCSC useScore option
+
+
+        this.useScore = config.useScore;
+      }
+
+      async postInit() {
+        if (typeof this.featureSource.getHeader === "function") {
+          this.header = await this.featureSource.getHeader();
+        } // Set properties from track line
+
+
+        if (this.header) {
+          this.setTrackProperties(this.header);
+        }
+
+        if (this.visibilityWindow === undefined && typeof this.featureSource.defaultVisibilityWindow === 'function') {
+          this.visibilityWindow = await this.featureSource.defaultVisibilityWindow();
+          this.featureSource.visibilityWindow = this.visibilityWindow; // <- this looks odd
+        }
+
+        return this;
+      }
+
+      supportsWholeGenome() {
+        return (this.config.indexed === false || !this.config.indexURL) && this.config.supportsWholeGenome !== false;
+      }
+
+      async getFeatures(chr, start, end, bpPerPixel) {
+        const visibilityWindow = this.visibilityWindow;
+        return this.featureSource.getFeatures({
+          chr,
+          start,
+          end,
+          bpPerPixel,
+          visibilityWindow
+        });
+      }
+
+      /**
+       * The required height in pixels required for the track content.   This is not the visible track height, which
+       * can be smaller (with a scrollbar) or larger.
+       *
+       * @param features
+       * @returns {*}
+       */
+      computePixelHeight(features) {
+        if (this.type === 'spliceJunctions') {
+          return this.height;
+        } else if (this.displayMode === "COLLAPSED") {
+          return this.margin + this.expandedRowHeight;
+        } else {
+          let maxRow = 0;
+
+          if (features && typeof features.forEach === "function") {
+            for (let feature of features) {
+              if (feature.row && feature.row > maxRow) {
+                maxRow = feature.row;
+              }
+            }
+          }
+
+          const height = this.margin + (maxRow + 1) * ("SQUISHED" === this.displayMode ? this.squishedRowHeight : this.expandedRowHeight);
+          return height;
+        }
+      }
+
+      draw(options) {
+        const featureList = options.features;
+        const ctx = options.context;
+        const bpPerPixel = options.bpPerPixel;
+        const bpStart = options.bpStart;
+        const pixelWidth = options.pixelWidth;
+        const pixelHeight = options.pixelHeight;
+        const bpEnd = bpStart + pixelWidth * bpPerPixel + 1;
+
+        if (!this.config.isMergedTrack) {
+          IGVGraphics.fillRect(ctx, 0, options.pixelTop, pixelWidth, pixelHeight, {
+            'fillStyle': "rgb(255, 255, 255)"
+          });
+        }
+
+        if (featureList) {
+          const rowFeatureCount = [];
+          options.rowLastX = [];
+
+          for (let feature of featureList) {
+            const row = feature.row || 0;
+
+            if (rowFeatureCount[row] === undefined) {
+              rowFeatureCount[row] = 1;
+            } else {
+              rowFeatureCount[row]++;
+            }
+
+            options.rowLastX[row] = -Number.MAX_SAFE_INTEGER;
+          }
+
+          if (this.config.type == 'spliceJunctions') {
+            junctionRenderingContext.referenceFrame = options.viewport.referenceFrame;
+            junctionRenderingContext.referenceFrameStart = junctionRenderingContext.referenceFrame.start;
+            junctionRenderingContext.referenceFrameEnd = junctionRenderingContext.referenceFrameStart + junctionRenderingContext.referenceFrame.toBP($(options.viewport.contentDiv).width()); // For a given viewport, records where features that are < 2px in width have been rendered already.
+            // This prevents wasteful rendering of multiple such features onto the same pixels.
+
+            junctionRenderingContext.featureZoomOutTracker = {};
+          }
+
+          let lastPxEnd = [];
+
+          for (let feature of featureList) {
+            if (feature.end < bpStart) continue;
+            if (feature.start > bpEnd) break;
+            const row = this.displayMode === 'COLLAPSED' ? 0 : feature.row;
+            const featureDensity = pixelWidth / rowFeatureCount[row];
+            options.drawLabel = options.labelAllFeatures || featureDensity > 10;
+            const pxEnd = Math.ceil((feature.end - bpStart) / bpPerPixel);
+            const last = lastPxEnd[row];
+
+            if (!last || pxEnd > last || this.config.type === 'spliceJunctions') {
+              this.render.call(this, feature, bpStart, bpPerPixel, pixelHeight, ctx, options);
+
+              if (this.config.type !== 'spliceJunctions') {
+                // Ensure a visible gap between features
+                const pxStart = Math.floor((feature.start - bpStart) / bpPerPixel);
+
+                if (last && pxStart - last <= 0) {
+                  ctx.globalAlpha = 0.5;
+                  IGVGraphics.strokeLine(ctx, pxStart, 0, pxStart, pixelHeight, {
+                    'strokeStyle': "rgb(255, 255, 255)"
+                  });
+                  ctx.globalAlpha = 1.0;
+                }
+
+                lastPxEnd[row] = pxEnd;
+              }
+            }
+          }
+        }
+      }
+
+      clickedFeatures(clickState, features) {
+        const y = clickState.y - this.margin;
+        const allFeatures = super.clickedFeatures(clickState, features);
+        let row;
+
+        switch (this.displayMode) {
+          case 'SQUISHED':
+            row = Math.floor(y / this.squishedRowHeight);
+            break;
+
+          case 'EXPANDED':
+            row = Math.floor(y / this.expandedRowHeight);
+            break;
+
+          default:
+            row = undefined;
+        }
+
+        return allFeatures.filter(function (feature) {
+          return row === undefined || feature.row === undefined || row === feature.row;
+        });
+      }
+      /**
+       * Return "popup data" for feature @ genomic location.  Data is an array of key-value pairs
+       */
+
+
+      popupData(clickState, features) {
+        features = this.clickedFeatures(clickState, features);
+        const genomicLocation = clickState.genomicLocation;
+        const data = [];
+
+        for (let feature of features) {
+          if (this.config.type === 'spliceJunctions') {
+            if (!feature.isVisible || !feature.attributes) {
+              continue;
+            }
+          }
+
+          const featureData = typeof feature.popupData === "function" ? feature.popupData(genomicLocation) : this.extractPopupData(feature._f || feature, this.getGenomeId());
+
+          if (featureData) {
+            if (data.length > 0) {
+              data.push("<hr/><hr/>");
+            }
+
+            Array.prototype.push.apply(data, featureData);
+          }
+        }
+
+        return data;
+      }
+
+      menuItemList() {
+        const self = this;
+        const menuItems = [];
+
+        if (this.render === renderSnp) {
+          ["function", "class"].forEach(function (colorScheme) {
+            menuItems.push({
+              object: createCheckbox$1('Color by ' + colorScheme, colorScheme === self.colorBy),
+              click: function () {
+                self.colorBy = colorScheme;
+                self.trackView.repaintViews();
+              }
+            });
+          });
+          menuItems.push({
+            object: $('<div class="igv-track-menu-border-top">')
+          });
+        }
+
+        menuItems.push({
+          object: $('<div class="igv-track-menu-border-top">')
+        });
+        ["COLLAPSED", "SQUISHED", "EXPANDED"].forEach(function (displayMode) {
+          const lut = {
+            "COLLAPSED": "Collapse",
+            "SQUISHED": "Squish",
+            "EXPANDED": "Expand"
+          };
+          menuItems.push({
+            object: createCheckbox$1(lut[displayMode], displayMode === self.displayMode),
+            click: function () {
+              self.displayMode = displayMode;
+              self.config.displayMode = displayMode;
+              self.trackView.checkContentHeight();
+              self.trackView.repaintViews();
+            }
+          });
+        });
+        return menuItems;
+      }
+
+      description() {
+        // if('snp' === this.type) {
+        if (renderSnp === this.render) {
+          let desc = "<html>" + this.name + "<hr>";
+          desc += '<em>Color By Function:</em><br>';
+          desc += '<span style="color:red">Red</span>: Coding-Non-Synonymous, Splice Site<br>';
+          desc += '<span style="color:green">Green</span>: Coding-Synonymous<br>';
+          desc += '<span style="color:blue">Blue</span>: Untranslated<br>';
+          desc += '<span style="color:black">Black</span>: Intron, Locus, Unknown<br><br>';
+          desc += '<em>Color By Class:</em><br>';
+          desc += '<span style="color:red">Red</span>: Deletion<br>';
+          desc += '<span style="color:green">Green</span>: MNP<br>';
+          desc += '<span style="color:blue">Blue</span>: Microsatellite, Named<br>';
+          desc += '<span style="color:black">Black</span>: Indel, Insertion, SNP';
+          desc += "</html>";
+          return desc;
+        } else {
+          return this.name;
+        }
+      }
+
+      /**
+       * Called when the track is removed.  Do any needed cleanup here
+       */
+      dispose() {
+        this.trackView = undefined;
+      }
+
+    }
+    /**
+     * Monitors track drag events, updates label position to ensure that they're always visible.
+     * @param track
+     */
+
+
+    function monitorTrackDrag(track) {
+      if (track.browser.on) {
+        track.browser.on('trackdragend', onDragEnd);
+        track.browser.on('trackremoved', unSubscribe);
+      }
+
+      function onDragEnd() {
+        if (track.trackView && track.displayMode !== "SQUISHED") {
+          track.trackView.repaintViews(); // TODO -- refine this to the viewport that was dragged after DOM refactor
+        }
+      }
+
+      function unSubscribe(removedTrack) {
+        if (track.browser.un && track === removedTrack) {
+          track.browser.un('trackdrag', onDragEnd);
+          track.browser.un('trackremoved', unSubscribe);
+        }
+      }
+    }
+    /**
+     * @param feature
+     * @param bpStart  genomic location of the left edge of the current canvas
+     * @param xScale  scale in base-pairs per pixel
+     * @returns {{px: number, px1: number, pw: number, h: number, py: number}}
+     */
+
+
+    function calculateFeatureCoordinates(feature, bpStart, xScale) {
+      let px = (feature.start - bpStart) / xScale;
+      let px1 = (feature.end - bpStart) / xScale; //px = Math.round((feature.start - bpStart) / xScale),
+      //px1 = Math.round((feature.end - bpStart) / xScale),
+
+      let pw = px1 - px;
+
+      if (pw < 3) {
+        pw = 3;
+        px -= 1.5;
+      }
+
+      return {
+        px: px,
+        px1: px1,
+        pw: pw
+      };
+    }
+    /**
+     * Return color for feature.  Called in the context of a FeatureTrack instance.
+     * @param feature
+     * @returns {string}
+     */
+
+
+    function getColorForFeature(feature) {
+      let color;
+
+      if (this.altColor && "-" === feature.strand) {
+        color = this.altColor;
+      } else if (this.color) {
+        color = this.color; // Explicit setting via menu, or possibly track line if !config.color
+      } else if (this.config.colorBy) {
+        const colorByValue = feature[this.config.colorBy.field];
+
+        if (colorByValue) {
+          color = this.config.colorBy.pallete[colorByValue]; // This is an undocumented option, and its not clear if its used
+        }
+      } else if (feature.color) {
+        color = feature.color; // Explicit color for feature
+      } else {
+        color = this.defaultColor; // Track default
+      }
+
+      if (feature.alpha && feature.alpha !== 1) {
+        color = IGVColor.addAlpha(color, feature.alpha);
+      } else if (this.useScore && feature.score && !Number.isNaN(feature.score)) {
+        // UCSC useScore option, for scores between 0-1000.  See https://genome.ucsc.edu/goldenPath/help/customTrack.html#TRACK
+        const min = this.config.min ? this.config.min : 0; //getViewLimitMin(track);
+
+        const max = this.config.max ? this.config.max : 1000; //getViewLimitMax(track);
+
+        const alpha = getAlpha(min, max, feature.score);
+        feature.alpha = alpha; // Avoid computing again
+
+        color = IGVColor.addAlpha(color, alpha);
+      }
+
+      function getAlpha(min, max, score) {
+        const binWidth = (max - min) / 9;
+        const binNumber = Math.floor((score - min) / binWidth);
+        return Math.min(1.0, 0.2 + binNumber * 0.8 / 9);
+      }
+
+      return color;
+    }
+    /**
+     *
+     * @param feature
+     * @param bpStart  genomic location of the left edge of the current canvas
+     * @param xScale  scale in base-pairs per pixel
+     * @param pixelHeight  pixel height of the current canvas
+     * @param ctx  the canvas 2d context
+     * @param options  genomic state
+     */
+
+
+    function renderFeature(feature, bpStart, xScale, pixelHeight, ctx, options) {
+      let color = getColorForFeature.call(this, feature);
+      ctx.fillStyle = color;
+      ctx.strokeStyle = color;
+      let h;
+      let py;
+
+      if (this.displayMode === "SQUISHED" && feature.row !== undefined) {
+        h = this.featureHeight / 2;
+        py = this.margin + this.squishedRowHeight * feature.row;
+      } else if (this.displayMode === "EXPANDED" && feature.row !== undefined) {
+        h = this.featureHeight;
+        py = this.margin + this.expandedRowHeight * feature.row;
+      } else {
+        // collapsed
+        h = this.featureHeight;
+        py = this.margin;
+      }
+
+      const cy = py + h / 2;
+      const h2 = h / 2;
+      const py2 = cy - h2 / 2;
+      const exonCount = feature.exons ? feature.exons.length : 0;
+      const coord = calculateFeatureCoordinates(feature, bpStart, xScale);
+      const step = this.arrowSpacing;
+      const direction = feature.strand === '+' ? 1 : feature.strand === '-' ? -1 : 0;
+
+      if (exonCount === 0) {
+        // single-exon transcript
+        ctx.fillRect(coord.px, py, coord.pw, h); // Arrows
+        // Do not draw if strand is not +/-
+
+        if (direction !== 0) {
+          ctx.fillStyle = "white";
+          ctx.strokeStyle = "white";
+
+          for (let x = coord.px + step / 2; x < coord.px1; x += step) {
+            // draw arrowheads along central line indicating transcribed orientation
+            IGVGraphics.strokeLine(ctx, x - direction * 2, cy - 2, x, cy);
+            IGVGraphics.strokeLine(ctx, x - direction * 2, cy + 2, x, cy);
+          }
+
+          ctx.fillStyle = color;
+          ctx.strokeStyle = color;
+        }
+      } else {
+        // multi-exon transcript
+        IGVGraphics.strokeLine(ctx, coord.px + 1, cy, coord.px1 - 1, cy); // center line for introns
+
+        const pixelWidth = options.pixelWidth;
+        const xLeft = Math.max(0, coord.px) + step / 2;
+        const xRight = Math.min(pixelWidth, coord.px1);
+
+        for (let x = xLeft; x < xRight; x += step) {
+          // draw arrowheads along central line indicating transcribed orientation
+          IGVGraphics.strokeLine(ctx, x - direction * 2, cy - 2, x, cy);
+          IGVGraphics.strokeLine(ctx, x - direction * 2, cy + 2, x, cy);
+        }
+
+        for (let e = 0; e < exonCount; e++) {
+          // draw the exons
+          const exon = feature.exons[e];
+          let ePx = Math.round((exon.start - bpStart) / xScale);
+          let ePx1 = Math.round((exon.end - bpStart) / xScale);
+          let ePw = Math.max(1, ePx1 - ePx);
+          let ePxU;
+
+          if (ePx + ePw < 0) {
+            continue; // Off the left edge
+          }
+
+          if (ePx > pixelWidth) {
+            break; // Off the right edge
+          }
+
+          if (exon.utr) {
+            ctx.fillRect(ePx, py2, ePw, h2); // Entire exon is UTR
+          } else {
+            if (exon.cdStart) {
+              ePxU = Math.round((exon.cdStart - bpStart) / xScale);
+              ctx.fillRect(ePx, py2, ePxU - ePx, h2); // start is UTR
+
+              ePw -= ePxU - ePx;
+              ePx = ePxU;
+            }
+
+            if (exon.cdEnd) {
+              ePxU = Math.round((exon.cdEnd - bpStart) / xScale);
+              ctx.fillRect(ePxU, py2, ePx1 - ePxU, h2); // start is UTR
+
+              ePw -= ePx1 - ePxU;
+              ePx1 = ePxU;
+            }
+
+            ctx.fillRect(ePx, py, ePw, h); // Arrows
+
+            if (ePw > step + 5 && direction !== 0) {
+              ctx.fillStyle = "white";
+              ctx.strokeStyle = "white";
+
+              for (let x = ePx + step / 2; x < ePx1; x += step) {
+                // draw arrowheads along central line indicating transcribed orientation
+                IGVGraphics.strokeLine(ctx, x - direction * 2, cy - 2, x, cy);
+                IGVGraphics.strokeLine(ctx, x - direction * 2, cy + 2, x, cy);
+              }
+
+              ctx.fillStyle = color;
+              ctx.strokeStyle = color;
+            }
+          }
+        }
+      }
+
+      if (options.drawLabel && this.displayMode !== "SQUISHED") {
+        renderFeatureLabel.call(this, ctx, feature, coord.px, coord.px1, py, options.referenceFrame, options);
+      }
+    }
+    /**
+     * @param ctx       the canvas 2d context
+     * @param feature
+     * @param featureX  feature start x-coordinate
+     * @param featureX1 feature end x-coordinate
+     * @param featureY  feature y-coordinate
+     * @param windowX   visible window start x-coordinate
+     * @param windowX1  visible window end x-coordinate
+     * @param referenceFrame  genomic state
+     * @param options  options
+     */
+
+
+    function renderFeatureLabel(ctx, feature, featureX, featureX1, featureY, referenceFrame, options) {
+      let name = feature.name;
+      if (name === undefined && feature.gene) name = feature.gene.name;
+      if (name === undefined) name = feature.id || feature.ID;
+      if (!name || name === '.') return;
+      let pixelXOffset = options.pixelXOffset || 0;
+      const t1 = Math.max(featureX, -pixelXOffset);
+      const t2 = Math.min(featureX1, -pixelXOffset + options.viewportWidth);
+      const centerX = (t1 + t2) / 2;
+      let transform;
+
+      if (this.displayMode === "COLLAPSED" && this.labelDisplayMode === "SLANT") {
+        transform = {
+          rotate: {
+            angle: 45
+          }
+        };
+      }
+
+      const labelY = getFeatureLabelY(featureY, transform);
+      let color = getColorForFeature.call(this, feature);
+      let geneColor;
+      let gtexSelection = false;
+
+      if (referenceFrame.selection && GtexUtils.gtexLoaded) {
+        // TODO -- for gtex, figure out a better way to do this
+        gtexSelection = true;
+        geneColor = referenceFrame.selection.colorForGene(name);
+      }
+
+      const geneFontStyle = {
+        textAlign: "SLANT" === this.labelDisplayMode ? undefined : 'center',
+        fillStyle: geneColor || color,
+        strokeStyle: geneColor || color
+      };
+      const textBox = ctx.measureText(name);
+      const xleft = centerX - textBox.width / 2;
+      const xright = centerX + textBox.width / 2;
+
+      if (options.labelAllFeatures || xleft > options.rowLastX[feature.row] || gtexSelection) {
+        options.rowLastX[feature.row] = xright;
+        IGVGraphics.fillText(ctx, name, centerX, labelY, geneFontStyle, transform);
+      }
+    }
+
+    function getFeatureLabelY(featureY, transform) {
+      return transform ? featureY + 20 : featureY + 25;
+    }
+    /**
+     *
+     * @param feature
+     * @param bpStart  genomic location of the left edge of the current canvas
+     * @param xScale  scale in base-pairs per pixel
+     * @param pixelHeight  pixel height of the current canvas
+     * @param ctx  the canvas 2d context
+     */
+
+
+    function renderFusionJuncSpan(feature, bpStart, xScale, pixelHeight, ctx) {
+      var py;
+      var rowHeight = this.displayMode === "EXPANDED" ? this.expandedRowHeight : this.squishedRowHeight;
+
+      if (this.display === "COLLAPSED") {
+        py = this.margin;
+      }
+
+      if (this.displayMode === "SQUISHED" && feature.row !== undefined) {
+        py = this.margin + rowHeight * feature.row;
+      } else if (this.displayMode === "EXPANDED" && feature.row !== undefined) {
+        py = this.margin + rowHeight * feature.row;
+      }
+
+      var cy = py + 0.5 * rowHeight;
+      var topY = cy - 0.5 * rowHeight;
+      var bottomY = cy + 0.5 * rowHeight; // draw the junction arc
+
+      var junctionLeftPx = Math.round((feature.junction_left - bpStart) / xScale);
+      var junctionRightPx = Math.round((feature.junction_right - bpStart) / xScale);
+      ctx.beginPath();
+      ctx.moveTo(junctionLeftPx, cy);
+      ctx.bezierCurveTo(junctionLeftPx, topY, junctionRightPx, topY, junctionRightPx, cy);
+      ctx.lineWidth = 1 + Math.log(feature.num_junction_reads) / Math.log(2);
+      ctx.strokeStyle = 'blue';
+      ctx.stroke(); // draw the spanning arcs
+
+      var spanningCoords = feature.spanning_frag_coords;
+
+      for (var i = 0; i < spanningCoords.length; i++) {
+        var spanningInfo = spanningCoords[i];
+        var spanLeftPx = Math.round((spanningInfo.left - bpStart) / xScale);
+        var spanRightPx = Math.round((spanningInfo.right - bpStart) / xScale);
+        ctx.beginPath();
+        ctx.moveTo(spanLeftPx, cy);
+        ctx.bezierCurveTo(spanLeftPx, bottomY, spanRightPx, bottomY, spanRightPx, cy);
+        ctx.lineWidth = 1;
+        ctx.strokeStyle = 'purple';
+        ctx.stroke();
+      }
+    }
+    /**
+     *
+     * @param feature
+     * @param bpStart  genomic location of the left edge of the current canvas
+     * @param xScale  scale in base-pairs per pixel
+     * @param pixelHeight  pixel height of the current canvas
+     * @param ctx  the canvas 2d context
+     */
+
+
+    function renderJunctions(feature, bpStart, xScale, pixelHeight, ctx) {
+      // cache whether this junction is rendered or filtered out. Use later to exclude non-rendered junctions from click detection.
+      feature.isVisible = false;
+      const junctionLeftPx = Math.round((feature.start - bpStart) / xScale);
+      const junctionRightPx = Math.round((feature.end - bpStart) / xScale);
+      const junctionMiddlePx = (junctionLeftPx + junctionRightPx) / 2;
+
+      if (junctionRightPx - junctionLeftPx <= 3) {
+        if (junctionMiddlePx in junctionRenderingContext.featureZoomOutTracker) {
+          return;
+        }
+
+        junctionRenderingContext.featureZoomOutTracker[junctionMiddlePx] = true;
+      } // TODO: cache filter and pixel calculations by doing them earlier when features are initially parsed?
+
+
+      if (this.config.hideAnnotatedJunctions && feature.attributes.annotated_junction === "true") {
+        return;
+      }
+
+      if (this.config.hideUnannotatedJunctions && feature.attributes.annotated_junction === "false") {
+        return;
+      }
+
+      if (this.config.hideMotifs && this.config.hideMotifs.includes(feature.attributes.motif)) {
+        return;
+      }
+
+      if (this.config.hideStrand === feature.strand) {
+        return;
+      } // check if splice junction is inside viewport
+
+
+      if (this.config.minJunctionEndsVisible) {
+        let numJunctionEndsVisible = 0;
+
+        if (feature.start >= junctionRenderingContext.referenceFrameStart && feature.start <= junctionRenderingContext.referenceFrameEnd) {
+          numJunctionEndsVisible += 1;
+        }
+
+        if (feature.end >= junctionRenderingContext.referenceFrameStart && feature.end <= junctionRenderingContext.referenceFrameEnd) {
+          numJunctionEndsVisible += 1;
+        }
+
+        if (numJunctionEndsVisible < this.config.minJunctionEndsVisible) {
+          return;
+        }
+      }
+
+      let uniquelyMappedReadCount;
+      let multiMappedReadCount;
+      let totalReadCount;
+
+      if (feature.attributes.uniquely_mapped) {
+        uniquelyMappedReadCount = parseInt(feature.attributes.uniquely_mapped);
+
+        if (uniquelyMappedReadCount < this.config.minUniquelyMappedReads) {
+          return;
+        }
+
+        multiMappedReadCount = parseInt(feature.attributes.multi_mapped);
+        totalReadCount = uniquelyMappedReadCount + multiMappedReadCount;
+
+        if (totalReadCount < this.config.minTotalReads) {
+          return;
+        }
+
+        if (totalReadCount > 0 && multiMappedReadCount / totalReadCount > this.config.maxFractionMultiMappedReads) {
+          return;
+        }
+
+        if (feature.attributes.maximum_spliced_alignment_overhang && parseInt(feature.attributes.maximum_spliced_alignment_overhang) < this.config.minSplicedAlignmentOverhang) {
+          return;
+        }
+      }
+
+      let numSamplesWithThisJunction;
+
+      if (feature.attributes.num_samples_with_this_junction) {
+        numSamplesWithThisJunction = parseInt(feature.attributes.num_samples_with_this_junction);
+
+        if (this.config.minSamplesWithThisJunction && numSamplesWithThisJunction < this.config.minSamplesWithThisJunction) {
+          return;
+        }
+
+        if (this.config.maxSamplesWithThisJunction && numSamplesWithThisJunction > this.config.maxSamplesWithThisJunction) {
+          return;
+        }
+
+        if (feature.attributes.num_samples_total) {
+          feature.attributes.percent_samples_with_this_junction = 100 * numSamplesWithThisJunction / parseFloat(feature.attributes.num_samples_total);
+
+          if (this.config.minPercentSamplesWithThisJunction) {
+            if (feature.attributes.percent_samples_with_this_junction < this.config.minPercentSamplesWithThisJunction || feature.attributes.percent_samples_with_this_junction > this.config.maxPercentSamplesWithThisJunction) {
+              return;
+            }
+          }
+        }
+      }
+
+      const py = this.margin;
+      const rowHeight = this.height;
+      const cy = py + 0.5 * rowHeight;
+      let topY = py;
+      const bottomY = py + rowHeight;
+      const bezierBottomY = bottomY - 10; // draw the junction arc
+
+      const bezierControlLeftPx = (junctionLeftPx + junctionMiddlePx) / 2;
+      const bezierControlRightPx = (junctionMiddlePx + junctionRightPx) / 2;
+      let lineWidth = 1;
+
+      if (feature.attributes.line_width) {
+        lineWidth = parseFloat(feature.attributes.line_width);
+      } else {
+        if (this.config.thicknessBasedOn === undefined || this.config.thicknessBasedOn === 'numUniqueReads') {
+          lineWidth = uniquelyMappedReadCount;
+        } else if (this.config.thicknessBasedOn === 'numReads') {
+          lineWidth = totalReadCount;
+        } else if (this.config.thicknessBasedOn === 'numSamplesWithThisJunction') {
+          if (numSamplesWithThisJunction !== undefined) {
+            lineWidth = numSamplesWithThisJunction;
+          }
+        }
+
+        lineWidth = 1 + Math.log(lineWidth + 1) / Math.log(12);
+      }
+
+      let bounceHeight;
+
+      if (this.config.bounceHeightBasedOn === undefined || this.config.bounceHeightBasedOn === 'random') {
+        // randomly but deterministically stagger topY coordinates to reduce overlap
+        bounceHeight = (feature.start + feature.end) % 7;
+      } else if (this.config.bounceHeightBasedOn === 'distance') {
+        bounceHeight = 6 * (feature.end - feature.start) / (junctionRenderingContext.referenceFrameEnd - junctionRenderingContext.referenceFrameStart);
+      } else if (this.config.bounceHeightBasedOn === 'thickness') {
+        bounceHeight = 2 * lineWidth;
+      }
+
+      topY += rowHeight * Math.max(7 - bounceHeight, 0) / 10;
+      let color;
+
+      if (feature.attributes.color) {
+        color = feature.attributes.color; // Explicit setting
+      } else if (this.config.colorBy === undefined || this.config.colorBy === 'numUniqueReads') {
+        color = uniquelyMappedReadCount > this.config.colorByNumReadsThreshold ? 'blue' : '#AAAAAA'; // color gradient?
+      } else if (this.config.colorBy === 'numReads') {
+        color = totalReadCount > this.config.colorByNumReadsThreshold ? 'blue' : '#AAAAAA';
+      } else if (this.config.colorBy === 'isAnnotatedJunction') {
+        color = feature.attributes.annotated_junction === "true" ? '#b0b0ec' : 'orange';
+      } else if (this.config.colorBy === 'strand') {
+        color = feature.strand === "+" ? '#b0b0ec' : '#ecb0b0';
+      } else if (this.config.colorBy === 'motif') {
+        color = JUNCTION_MOTIF_PALETTE.getColor(feature.attributes.motif);
+      } else {
+        color = '#AAAAAA';
+      }
+
+      let label = "";
+
+      if (feature.attributes.label) {
+        label = feature.attributes.label.replace(/_/g, " ");
+      } else if (this.config.labelWith === undefined || this.config.labelWith === 'uniqueReadCount') {
+        //default label
+        label = uniquelyMappedReadCount;
+      } else if (this.config.labelWith === 'totalReadCount') {
+        label = totalReadCount;
+      } else if (this.config.labelWith === 'numSamplesWithThisJunction') {
+        if (numSamplesWithThisJunction !== undefined) {
+          label = numSamplesWithThisJunction;
+        }
+      } else if (this.config.labelWith === 'percentSamplesWithThisJunction') {
+        if (feature.attributes.percent_samples_with_this_junction !== undefined) {
+          label = feature.attributes.percent_samples_with_this_junction.toFixed(0) + '%';
+        }
+      } else if (this.config.labelWith === 'motif') {
+        if (feature.attributes.motif !== undefined) {
+          label += feature.attributes.motif;
+        }
+      }
+
+      if (this.config.labelWithInParen === 'uniqueReadCount') {
+        label += ' (' + uniquelyMappedReadCount + ')';
+      } else if (this.config.labelWithInParen === 'totalReadCount') {
+        label += ' (' + totalReadCount + ')';
+      } else if (this.config.labelWithInParen === 'multiMappedReadCount') {
+        if (multiMappedReadCount > 0) {
+          label += ' (+' + multiMappedReadCount + ')';
+        }
+      } else if (this.config.labelWithInParen === 'numSamplesWithThisJunction') {
+        if (numSamplesWithThisJunction !== undefined) {
+          label += ' (' + numSamplesWithThisJunction + ')';
+        }
+      } else if (this.config.labelWithInParen === 'percentSamplesWithThisJunction') {
+        if (feature.attributes.percent_samples_with_this_junction !== undefined) {
+          label += ' (' + feature.attributes.percent_samples_with_this_junction.toFixed(0) + '%)';
+        }
+      } else if (this.config.labelWithInParen === 'motif') {
+        if (feature.attributes.motif !== undefined) {
+          label += ` ${feature.attributes.motif}`;
+        }
+      } // data source: STAR splice junctions (eg. SJ.out.tab file converted to bed).
+      // .bed "name" field used to store unique + multi-mapped read counts, so:
+      // feature.score:  unique spanning read counts
+      // feature.name:   unique + multi-mapped spanning read counts
+      //example feature:  { chr: "chr17", start: 39662344, end: 39662803, name: "59", row: 0, score: 38, strand: "+"}
+
+
+      feature.isVisible = true;
+      ctx.beginPath();
+      ctx.moveTo(junctionLeftPx, bezierBottomY);
+      ctx.bezierCurveTo(bezierControlLeftPx, topY, bezierControlRightPx, topY, junctionRightPx, bezierBottomY);
+      ctx.lineWidth = lineWidth;
+      ctx.strokeStyle = color;
+      ctx.stroke();
+
+      const drawArrowhead = (ctx, x, y, size) => {
+        //TODO draw better arrow heads: https://stackoverflow.com/questions/21052972/curved-thick-arrows-on-canvas
+        ctx.beginPath();
+        ctx.moveTo(x, y);
+        ctx.lineTo(x - size / 2, y - size);
+        ctx.lineTo(x + size / 2, y - size);
+        ctx.lineTo(x, y);
+        ctx.closePath();
+        ctx.fill();
+      };
+
+      if (feature.attributes.left_shape || feature.attributes.right_shape) {
+        ctx.fillStyle = color;
+        const arrowSize = ctx.lineWidth > 2 ? 10 : 7;
+
+        if (feature.attributes.left_shape) {
+          drawArrowhead(ctx, junctionLeftPx, bezierBottomY, arrowSize);
+        }
+
+        if (feature.attributes.right_shape) {
+          drawArrowhead(ctx, junctionRightPx, bezierBottomY, arrowSize);
+        }
+      }
+
+      ctx.fillText(label, junctionMiddlePx - ctx.measureText(label).width / 2, (7 * topY + cy) / 8);
+    } // SNP constants
+
+
+    const codingNonSynonSet = new Set(['nonsense', 'missense', 'stop-loss', 'frameshift', 'cds-indel']);
+    const codingSynonSet = new Set(['coding-synon']);
+    const spliceSiteSet = new Set(['splice-3', 'splice-5']);
+    const untranslatedSet = new Set(['untranslated-5', 'untranslated-3']);
+    /**
+     * Renderer for a UCSC snp track
+     *
+     * @param snp
+     * @param bpStart  genomic location of the left edge of the current canvas
+     * @param xScale  scale in base-pairs per pixel
+     * @param pixelHeight  pixel height of the current canvas
+     * @param ctx  the canvas 2d context
+     */
+
+    function renderSnp(snp, bpStart, xScale, pixelHeight, ctx) {
+      var coord = calculateFeatureCoordinates(snp, bpStart, xScale),
+          py = this.margin,
+          h,
+          colorArrLength = this.snpColors.length,
+          colorPriority;
+      h = this.displayMode === "squished" ? this.squishedRowHeight : this.expandedRowHeight;
+
+      switch (this.colorBy) {
+        case 'function':
+          colorPriority = colorByFunc(snp.func);
+          break;
+
+        case 'class':
+          colorPriority = colorByClass(snp['class']);
+      }
+
+      ctx.fillStyle = this.snpColors[colorPriority];
+      ctx.fillRect(coord.px, py, coord.pw, h); // Coloring functions, convert a value to a priority
+
+      function colorByFunc(theFunc) {
+        var priorities;
+        var funcArray = theFunc.split(','); // possible func values
+
+        priorities = funcArray.map(function (func) {
+          if (codingNonSynonSet.has(func) || spliceSiteSet.has(func)) {
+            return colorArrLength - 1;
+          } else if (codingSynonSet.has(func)) {
+            return colorArrLength - 2;
+          } else if (untranslatedSet.has(func)) {
+            return colorArrLength - 3;
+          } else {
+            // locusSet.has(func) || intronSet.has(func)
+            return 0;
+          }
+        });
+        return priorities.reduce(function (a, b) {
+          return Math.max(a, b);
+        });
+      }
+
+      function colorByClass(cls) {
+        if (cls === 'deletion') {
+          return colorArrLength - 1;
+        } else if (cls === 'mnp') {
+          return colorArrLength - 2;
+        } else if (cls === 'microsatellite' || cls === 'named') {
+          return colorArrLength - 3;
+        } else {
+          // cls === 'single' || cls === 'in-del' || cls === 'insertion'
+          return 0;
+        }
+      }
+    }
+
+    function paintAxis(ctx, pixelWidth, pixelHeight) {
+      var x1,
+          x2,
+          y1,
+          y2,
+          a,
+          b,
+          reference,
+          shim,
+          font = {
+        'font': 'normal 10px Arial',
+        'textAlign': 'right',
+        'strokeStyle': "black"
+      };
+
+      if (undefined === this.dataRange || undefined === this.dataRange.max || undefined === this.dataRange.min) {
+        return;
+      }
+
+      IGVGraphics.fillRect(ctx, 0, 0, pixelWidth, pixelHeight, {
+        'fillStyle': "rgb(255, 255, 255)"
+      });
+      reference = 0.95 * pixelWidth;
+      x1 = reference - 8;
+      x2 = reference; //shim = 0.5 * 0.125;
+
+      shim = .01;
+      y1 = y2 = shim * pixelHeight;
+      a = {
+        x: x2,
+        y: y1
+      }; // tick
+
+      IGVGraphics.strokeLine(ctx, x1, y1, x2, y2, font);
+      IGVGraphics.fillText(ctx, prettyPrint(this.dataRange.max), x1 + 4, y1 + 12, font); //shim = 0.25 * 0.125;
+
+      y1 = y2 = (1.0 - shim) * pixelHeight;
+      b = {
+        x: x2,
+        y: y1
+      }; // tick
+
+      IGVGraphics.strokeLine(ctx, x1, y1, x2, y2, font);
+      IGVGraphics.fillText(ctx, prettyPrint(this.dataRange.min), x1 + 4, y1 - 4, font);
+      IGVGraphics.strokeLine(ctx, a.x, a.y, b.x, b.y, font);
+
+      function prettyPrint(number) {
+        // if number >= 100, show whole number
+        // if >= 1 show 1 significant digits
+        // if <  1 show 2 significant digits
+        if (number === 0) {
+          return "0";
+        } else if (Math.abs(number) >= 10) {
+          return number.toFixed();
+        } else if (Math.abs(number) >= 1) {
+          return number.toFixed(1);
+        } else {
+          return number.toFixed(2);
+        }
+      }
+    }
+
+    /*
+     * The MIT License (MIT)
+     *
+     * Copyright (c) 2014 Broad Institute
+     *
+     * Permission is hereby granted, free of charge, to any person obtaining a copy
+     * of this software and associated documentation files (the "Software"), to deal
+     * in the Software without restriction, including without limitation the rights
+     * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+     * copies of the Software, and to permit persons to whom the Software is
+     * furnished to do so, subject to the following conditions:
+     *
+     * The above copyright notice and this permission notice shall be included in
+     * all copies or substantial portions of the Software.
+     *
+     *
+     * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+     * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+     * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+     * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+     * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+     * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+     * THE SOFTWARE.
+     */
+    const DEFAULT_COLOR = "rgb(150,150,150)";
+
+    class WigTrack extends TrackBase {
+      constructor(config, browser) {
+        super(config, browser);
+      }
+
+      init(config) {
+        super.init(config);
+        this.type = "wig";
+        this.height = config.height || 50;
+        this.featureType = 'numeric';
+        this.paintAxis = paintAxis;
+        const format = config.format ? config.format.toLowerCase() : config.format;
+
+        if ("bigwig" === format) {
+          this.featureSource = new BWSource(config, this.browser.genome);
+        } else if ("tdf" === format) {
+          this.featureSource = new TDFSource(config, this.browser.genome);
+        } else {
+          this.featureSource = FeatureSource(config, this.browser.genome);
+        }
+
+        this.autoscale = config.autoscale || config.max === undefined;
+
+        if (!this.autoscale) {
+          this.dataRange = {
+            min: config.min || 0,
+            max: config.max
+          };
+        }
+
+        this.windowFunction = config.windowFunction || "mean";
+        this.graphType = config.graphType || "bar";
+        this.normalize = config.normalize; // boolean, for use with "TDF" files
+
+        this.scaleFactor = config.scaleFactor; // optional scale factor, ignored if normalize === true;
+      }
+
+      async postInit() {
+        const header = await this.getHeader();
+        if (header) this.setTrackProperties(header);
+      }
+
+      async getFeatures(chr, start, end, bpPerPixel) {
+        const features = await this.featureSource.getFeatures({
+          chr,
+          start,
+          end,
+          bpPerPixel,
+          windowFunction: this.windowFunction
+        });
+
+        if (this.normalize && this.featureSource.normalizationFactor) {
+          const scaleFactor = this.featureSource.normalizationFactor;
+
+          for (let f of features) {
+            f.value *= scaleFactor;
+          }
+        }
+
+        if (this.scaleFactor) {
+          const scaleFactor = this.scaleFactor;
+
+          for (let f of features) {
+            f.value *= scaleFactor;
+          }
+        }
+
+        return features;
+      }
+
+      menuItemList() {
+        return MenuUtils.numericDataMenuItems(this.trackView);
+      }
+
+      async getHeader() {
+        if (typeof this.featureSource.getHeader === "function") {
+          this.header = await this.featureSource.getHeader();
+        }
+
+        return this.header;
+      }
+
+      draw(options) {
+        const features = options.features;
+        const ctx = options.context;
+        const bpPerPixel = options.bpPerPixel;
+        const bpStart = options.bpStart;
+        const pixelWidth = options.pixelWidth;
+        const pixelHeight = options.pixelHeight;
+        const bpEnd = bpStart + pixelWidth * bpPerPixel + 1;
+        let lastPixelEnd = -1;
+        let lastValue = -1;
+        let lastNegValue = 1;
+        const posColor = this.color || DEFAULT_COLOR;
+        let baselineColor;
+
+        if (typeof posColor === "string" && posColor.startsWith("rgb(")) {
+          baselineColor = IGVColor.addAlpha(posColor, 0.1);
+        }
+
+        const yScale = yValue => {
+          return (this.dataRange.max - yValue) / (this.dataRange.max - this.dataRange.min) * pixelHeight;
+        };
+
+        if (features && features.length > 0) {
+          if (this.dataRange.min === undefined) this.dataRange.min = 0; // Max can be less than min if config.min is set but max left to autoscale.   If that's the case there is
+          // nothing to paint.
+
+          if (this.dataRange.max > this.dataRange.min) {
+            const y0 = this.dataRange.min == 0 ? pixelHeight : yScale(0);
+
+            for (let f of features) {
+              if (f.end < bpStart) continue;
+              if (f.start > bpEnd) break;
+              const x = Math.floor((f.start - bpStart) / bpPerPixel);
+              if (isNaN(x)) continue;
+              let y = yScale(f.value);
+              const rectEnd = Math.ceil((f.end - bpStart) / bpPerPixel);
+              const width = Math.max(1, rectEnd - x);
+              let c = f.value < 0 && this.altColor ? this.altColor : posColor;
+              const color = typeof c === "function" ? c(f.value) : c;
+
+              if (this.graphType === "points") {
+                const pointSize = this.config.pointSize || 3;
+                const px = x + width / 2;
+                IGVGraphics.fillCircle(ctx, px, y, pointSize / 2, {
+                  "fillStyle": color,
+                  "strokeStyle": color
+                });
+              } else {
+                let height = y - y0;
+
+                if (Math.abs(height) < 1) {
+                  height = height < 0 ? -1 : 1;
+                }
+
+                const pixelEnd = x + width;
+
+                if (pixelEnd > lastPixelEnd || f.value >= 0 && f.value > lastValue || f.value < 0 && f.value < lastNegValue) {
+                  IGVGraphics.fillRect(ctx, x, y0, width, height, {
+                    fillStyle: color
+                  });
+                }
+
+                lastValue = f.value;
+                lastPixelEnd = pixelEnd;
+              }
+            } // If the track includes negative values draw a baseline
+
+
+            if (this.dataRange.min < 0) {
+              const basepx = this.dataRange.max / (this.dataRange.max - this.dataRange.min) * options.pixelHeight;
+              IGVGraphics.strokeLine(ctx, 0, basepx, options.pixelWidth, basepx, {
+                strokeStyle: baselineColor
+              });
+            }
+          }
+        } // Draw guidelines
+
+
+        if (this.config.hasOwnProperty('guideLines')) {
+          for (let line of this.config.guideLines) {
+            if (line.hasOwnProperty('color') && line.hasOwnProperty('y') && line.hasOwnProperty('dotted')) {
+              let y = yScale(line.y);
+              let props = {
+                'strokeStyle': line['color'],
+                'strokeWidth': 2
+              };
+              if (line['dotted']) IGVGraphics.dashedLine(options.context, 0, y, options.pixelWidth, y, 5, props);else IGVGraphics.strokeLine(options.context, 0, y, options.pixelWidth, y, props);
+            }
+          }
+        }
+      }
+
+      popupData(clickState, features) {
+        // We use the featureCache property rather than method to avoid async load.  If the
+        // feature is not already loaded this won't work,  but the user wouldn't be mousing over it either.
+        features = this.clickedFeatures(clickState, features);
+
+        if (features && features.length > 0) {
+          const genomicLocation = clickState.genomicLocation;
+          const popupData = []; // Sort features based on distance from click
+
+          features.sort(function (a, b) {
+            const distA = Math.abs((a.start + a.end) / 2 - genomicLocation);
+            const distB = Math.abs((b.start + b.end) / 2 - genomicLocation);
+            return distA - distB;
+          }); // Display closest 10
+
+          const displayFeatures = features.length > 10 ? features.slice(0, 10) : features; // Resort in ascending order
+
+          displayFeatures.sort(function (a, b) {
+            return a.start - b.start;
+          });
+
+          for (let selectedFeature of displayFeatures) {
+            if (selectedFeature) {
+              if (popupData.length > 0) {
+                popupData.push("<hr/>");
+              }
+
+              let posString = selectedFeature.end - selectedFeature.start === 1 ? numberFormatter$1(selectedFeature.start + 1) : numberFormatter$1(selectedFeature.start + 1) + "-" + numberFormatter$1(selectedFeature.end);
+              popupData.push({
+                name: "Position:",
+                value: posString
+              });
+              popupData.push({
+                name: "Value:&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;",
+                value: numberFormatter$1(selectedFeature.value)
+              });
+            }
+          }
+
+          if (displayFeatures.length < features.length) {
+            popupData.push("<hr/>...");
+          }
+
+          return popupData;
+        } else {
+          return [];
+        }
+      }
+
+      supportsWholeGenome() {
+        if (typeof this.featureSource.supportsWholeGenome === 'function') {
+          return this.featureSource.supportsWholeGenome();
+        } else {
+          return false;
+        }
+      }
+      /**
+       * Called when the track is removed.  Do any needed cleanup here
+       */
+
+
+      dispose() {
+        this.trackView = undefined;
+      }
+
+    }
+
+    /**
+     *
+     * @param cs - object containing
+     * 1) array of threshold values defining bin boundaries in ascending order
+     * 2) array of colors for bins  (length == thresholds.length + 1)
+     * @constructor
+     */
+    function BinnedColorScale(cs) {
+      this.thresholds = cs.thresholds;
+      this.colors = cs.colors;
+    }
+
+    BinnedColorScale.prototype.getColor = function (value) {
+      for (let threshold of this.thresholds) {
+        if (value < threshold) {
+          return this.colors[this.thresholds.indexOf(threshold)];
+        }
+      }
+
+      return this.colors[this.colors.length - 1];
+    };
+    /**
+     *
+     * @param scale - object with the following properties
+     *           low
+     *           lowR
+     *           lowG
+     *           lowB
+     *           high
+     *           highR
+     *           highG
+     *           highB
+     *
+     * @constructor
+     */
+
+
+    function GradientColorScale(scale) {
+      this.scale = scale;
+      this.lowColor = "rgb(" + scale.lowR + "," + scale.lowG + "," + scale.lowB + ")";
+      this.highColor = "rgb(" + scale.highR + "," + scale.highG + "," + scale.highB + ")";
+      this.diff = scale.high - scale.low;
+    }
+
+    GradientColorScale.prototype.getColor = function (value) {
+      var scale = this.scale,
+          r,
+          g,
+          b,
+          frac;
+      if (value <= scale.low) return this.lowColor;else if (value >= scale.high) return this.highColor;
+      frac = (value - scale.low) / this.diff;
+      r = Math.floor(scale.lowR + frac * (scale.highR - scale.lowR));
+      g = Math.floor(scale.lowG + frac * (scale.highG - scale.lowG));
+      b = Math.floor(scale.lowB + frac * (scale.highB - scale.lowB));
+      return "rgb(" + r + "," + g + "," + b + ")";
+    };
+
+    class ConstantColorScale {
+      constructor(color) {
+        this.color = color;
+      }
+
+      getColor() {
+        return this.color;
+      }
+
+    }
+
+    /*
+     * The MIT License (MIT)
+     *
+     * Copyright (c) 2014 Broad Institute
+     *
+     * Permission is hereby granted, free of charge, to any person obtaining a copy
+     * of this software and associated documentation files (the "Software"), to deal
+     * in the Software without restriction, including without limitation the rights
+     * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+     * copies of the Software, and to permit persons to whom the Software is
+     * furnished to do so, subject to the following conditions:
+     *
+     * The above copyright notice and this permission notice shall be included in
+     * all copies or substantial portions of the Software.
+     *
+     *
+     * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+     * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+     * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+     * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+     * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+     * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+     * THE SOFTWARE.
+     */
+
+    class SegTrack extends TrackBase {
+      constructor(config, browser) {
+        super(config, browser);
+      }
+
+      init(config) {
+        super.init(config);
+        this.type = config.type || "seg";
+        this.isLog = config.isLog;
+        this.displayMode = config.displayMode || "EXPANDED"; // EXPANDED | SQUISHED -- TODO perhaps set his based on sample count
+
+        this.height = config.height || 300;
+        this.maxHeight = config.maxHeight || 500;
+        this.squishedRowHeight = config.sampleSquishHeight || config.squishedRowHeight || 2;
+        this.expandedRowHeight = config.sampleExpandHeight || config.expandedRowHeight || 13;
+        this.sampleHeight = this.squishedRowHeight; // Initial value, will get overwritten when rendered
+
+        if (config.color) {
+          this.color = config.color;
+        } else {
+          // Color scales for "seg" (copy number) tracks.
+          this.posColorScale = config.posColorScale || new GradientColorScale({
+            low: 0.1,
+            lowR: 255,
+            lowG: 255,
+            lowB: 255,
+            high: 1.5,
+            highR: 255,
+            highG: 0,
+            highB: 0
+          });
+          this.negColorScale = config.negColorScale || new GradientColorScale({
+            low: -1.5,
+            lowR: 0,
+            lowG: 0,
+            lowB: 255,
+            high: -0.1,
+            highR: 255,
+            highG: 255,
+            highB: 255
+          }); // Color table for mutation (mut and maf) tracks
+
+          this.colorTable = new ColorTable(config.colorTable || MUT_COLORS);
+        }
+
+        this.sampleKeys = [];
+        this.sampleNames = new Map();
+
+        if (config.samples) {
+          // Explicit setting, keys == names
+          for (let s of config.samples) {
+            this.sampleKeys.push(s);
+            this.sampleNames.set(s, s);
+          }
+
+          this.explicitSamples = true;
+        } //   this.featureSource = config.sourceType === "bigquery" ?
+        //       new igv.BigQueryFeatureSource(this.config) :
+
+
+        this.featureSource = FeatureSource(this.config, this.browser.genome);
+        this.initialSort = config.sort;
+      }
+
+      async postInit() {
+        if (typeof this.featureSource.getHeader === "function") {
+          this.header = await this.featureSource.getHeader();
+        } // Set properties from track line
+
+
+        if (this.header) {
+          this.setTrackProperties(this.header);
+        }
+      }
+
+      menuItemList() {
+        const menuItems = [];
+        const lut = {
+          "SQUISHED": "Squish",
+          "EXPANDED": "Expand",
+          "FILL": "Fill"
+        };
+        menuItems.push("<hr/>");
+        menuItems.push("Sample Height:");
+        const displayOptions = this.type === 'seg' ? ["SQUISHED", "EXPANDED", "FILL"] : ["SQUISHED", "EXPANDED"];
+
+        for (let displayMode of displayOptions) {
+          menuItems.push({
+            object: createCheckbox$1(lut[displayMode], displayMode === this.displayMode),
+            click: () => {
+              this.displayMode = displayMode;
+              this.config.displayMode = displayMode;
+              this.trackView.checkContentHeight();
+              this.trackView.repaintViews();
+            }
+          });
+        }
+
+        return menuItems;
+      }
+
+      hasSamples() {
+        return true; // SEG, MUT, and MAF tracks have samples by definition
+      }
+
+      getSamples() {
+        return {
+          names: this.sampleKeys.map(key => this.sampleNames.get(key)),
+          height: this.sampleHeight,
+          yOffset: 0
+        };
+      }
+
+      async getFeatures(chr, start, end) {
+        const features = await this.featureSource.getFeatures({
+          chr,
+          start,
+          end
+        });
+
+        if (this.initialSort) {
+          const sort = this.initialSort;
+          this.sortSamples(sort.chr, sort.start, sort.end, sort.direction, features);
+          this.initialSort = undefined; // Sample order is sorted,
+        }
+
+        return features;
+      }
+
+      draw({
+        context,
+        renderSVG,
+        pixelTop,
+        pixelWidth,
+        pixelHeight,
+        features,
+        bpPerPixel,
+        bpStart
+      }) {
+        IGVGraphics.fillRect(context, 0, 0, pixelWidth, pixelHeight, {
+          'fillStyle': "rgb(255, 255, 255)"
+        });
+
+        if (features && features.length > 0) {
+          this.checkForLog(features); // New segments could conceivably add new samples
+
+          this.updateSampleKeys(features); // Create a map for fast id -> row lookup
+
+          const samples = {};
+          this.sampleKeys.forEach(function (id, index) {
+            samples[id] = index;
+          });
+          let border;
+
+          switch (this.displayMode) {
+            case "FILL":
+              this.sampleHeight = pixelHeight / this.sampleKeys.length;
+              border = 0;
+              break;
+
+            case "SQUISHED":
+              this.sampleHeight = this.squishedRowHeight;
+              border = 0;
+              break;
+
+            default:
+              // EXPANDED
+              this.sampleHeight = this.expandedRowHeight;
+              border = 1;
+          }
+
+          const rowHeight = this.sampleHeight; // this.featureMap = new Map()
+
+          for (let segment of features) {
+            segment.pixelRect = undefined; // !important, reset this in case segment is not drawn
+          }
+
+          const pixelBottom = pixelTop + pixelHeight;
+          const bpEnd = bpStart + pixelWidth * bpPerPixel + 1;
+          const xScale = bpPerPixel;
+          this.sampleYStart = undefined;
+
+          for (let f of features) {
+            if (f.end < bpStart) continue;
+            if (f.start > bpEnd) break;
+            const sampleKey = f.sampleKey || f.sample;
+            f.row = samples[sampleKey];
+            const y = f.row * rowHeight + border;
+
+            if (undefined === this.sampleYStart) {
+              this.sampleYStart = y;
+            }
+
+            const bottom = y + rowHeight;
+
+            if (bottom < pixelTop || y > pixelBottom) {
+              continue;
+            }
+
+            const segmentStart = Math.max(f.start, bpStart); // const segmentStart = segment.start;
+
+            let x = Math.round((segmentStart - bpStart) / xScale);
+            const segmentEnd = Math.min(f.end, bpEnd); // const segmentEnd = segment.end;
+
+            const x1 = Math.round((segmentEnd - bpStart) / xScale);
+            let w = Math.max(1, x1 - x);
+            let color;
+            let h;
+
+            if (this.color) {
+              if (typeof this.color === "function") {
+                color = this.color(f);
+              } else {
+                color = this.color;
+              }
+            } else if ("mut" === this.type) {
+              color = this.colorTable.getColor(f.value.toLowerCase());
+              h = rowHeight - 2 * border;
+
+              if (w < 3) {
+                w = 3;
+                x -= 1;
+              }
+            } else {
+              // Assume seg track
+              let value = f.value;
+
+              if (!this.isLog) {
+                value = IGVMath.log2(value / 2);
+              }
+
+              if (value < -0.1) {
+                color = this.negColorScale.getColor(value);
+              } else if (value > 0.1) {
+                color = this.posColorScale.getColor(value);
+              } else {
+                color = "white";
+              }
+
+              let sh = rowHeight;
+
+              if (rowHeight < 0.25) {
+                const f = 0.1 + 2 * Math.abs(value);
+                sh = Math.min(1, f * rowHeight);
+              }
+
+              h = sh - 2 * border;
+            }
+
+            f.pixelRect = {
+              x,
+              y,
+              w,
+              h
+            }; // Use for diagnostic rendering
+            // context.fillStyle = randomRGB(180, 240)
+            // context.fillStyle = randomGrey(200, 255)
+
+            context.fillStyle = color;
+            context.fillRect(x, y, w, h);
+          }
+        }
+      }
+
+      checkForLog(features) {
+        if (this.isLog === undefined) {
+          this.isLog = false;
+
+          for (let feature of features) {
+            if (feature.value < 0) {
+              this.isLog = true;
+              return;
+            }
+          }
+        }
+      }
+      /**
+       * Optional method to compute pixel height to accomodate the list of features.  The implementation below
+       * has side effects (modifiying the samples hash).  This is unfortunate, but harmless.
+       *
+       * @param features
+       * @returns {number}
+       */
+
+
+      computePixelHeight(features) {
+        if (!features) return 0;
+        const sampleHeight = "SQUISHED" === this.displayMode ? this.squishedRowHeight : this.expandedRowHeight;
+        this.updateSampleKeys(features);
+        return this.sampleKeys.length * sampleHeight;
+      }
+      /**
+       * Sort samples by the average value over the genomic range in the direction indicated (1 = ascending, -1 descending)
+       */
+
+
+      async sortSamples(chr, start, end, direction, featureList) {
+        if (!featureList) {
+          featureList = await this.featureSource.getFeatures({
+            chr,
+            start,
+            end
+          });
+        }
+
+        if (!featureList) return;
+        this.updateSampleKeys(featureList);
+        const scores = {};
+        const d2 = direction === "ASC" ? 1 : -1;
+
+        const sortSeg = () => {
+          // Compute weighted average score for each sample
+          const bpLength = end - start + 1;
+
+          for (let segment of featureList) {
+            if (segment.end < start) continue;
+            if (segment.start > end) break;
+            const min = Math.max(start, segment.start);
+            const max = Math.min(end, segment.end);
+            const f = (max - min) / bpLength;
+            const sampleKey = segment.sampleKey || segment.sample;
+            const s = scores[sampleKey] || 0;
+            scores[sampleKey] = s + f * segment.value;
+          } // Now sort sample names by score
+
+
+          this.sampleKeys.sort(function (a, b) {
+            let s1 = scores[a];
+            let s2 = scores[b];
+            if (!s1) s1 = d2 * Number.MAX_VALUE;
+            if (!s2) s2 = d2 * Number.MAX_VALUE;
+            if (s1 === s2) return 0;else if (s1 > s2) return d2;else return d2 * -1;
+          });
+        };
+
+        const sortMut = () => {
+          // Compute weighted average score for each sample
+          for (let segment of featureList) {
+            if (segment.end < start) continue;
+            if (segment.start > end) break;
+            const sampleKey = segment.sampleKey || segment.sample;
+
+            if (!scores.hasOwnProperty(sampleKey) || segment.value.localeCompare(scores[sampleKey]) > 0) {
+              scores[sampleKey] = segment.value;
+            }
+          } // Now sort sample names by score
+
+
+          this.sampleKeys.sort(function (a, b) {
+            let sa = scores[a] || "";
+            let sb = scores[b] || "";
+            return d2 * sa.localeCompare(sb);
+          });
+        };
+
+        if ("mut" === this.type) {
+          sortMut();
+        } else {
+          sortSeg();
+        }
+
+        this.trackView.repaintViews(); // self.trackView.$viewport.scrollTop(0);
+      }
+
+      clickedFeatures(clickState, features) {
+        const allFeatures = super.clickedFeatures(clickState, features);
+        return filterByRow(allFeatures, clickState.y);
+
+        function filterByRow(features, y) {
+          return features.filter(function (feature) {
+            const rect = feature.pixelRect;
+            return rect && y >= rect.y && y <= rect.y + rect.h;
+          });
+        }
+      }
+
+      popupData(clickState, featureList) {
+        featureList = this.clickedFeatures(clickState);
+        const items = [];
+
+        for (let feature of featureList) {
+          if (items.length > 0) {
+            items.push("<hr/>");
+          }
+
+          if (typeof feature.popupData === 'function') {
+            const data = feature.popupData();
+            Array.prototype.push.apply(items, data);
+          } else {
+            const filteredProperties = new Set(['chr', 'start', 'end', 'sample', 'value', 'row', 'color', 'sampleKey', 'uniqueSampleKey', 'sampleId', 'chromosome', 'uniquePatientKey']); // hack for whole genome features, which save the original feature as "_f"
+
+            const f = feature._f || feature;
+            items.push({
+              name: 'Sample',
+              value: f.sample
+            });
+            const valueString = this.type === 'seg' ? numberFormatter$1(f.value) : f.value;
+            items.push({
+              name: 'Value',
+              value: valueString
+            });
+            const locus = `${f.chr}:${numberFormatter$1(f.start + 1)}-${numberFormatter$1(f.end)}`;
+            items.push({
+              name: 'Locus',
+              value: locus
+            });
+            items.push('<hr/>');
+
+            for (let property of Object.keys(f)) {
+              if (!filteredProperties.has(property) && isSimpleType(f[property])) {
+                items.push({
+                  name: property,
+                  value: f[property]
+                });
+              }
+            }
+          }
+        }
+
+        return items;
+      }
+
+      contextMenuItemList(clickState) {
+        const referenceFrame = clickState.viewport.referenceFrame;
+        const genomicLocation = clickState.genomicLocation; // Define a region 5 "pixels" wide in genomic coordinates
+
+        const sortDirection = this.config.sort ? this.config.sort.direction === "ASC" ? "DESC" : "ASC" : // Toggle from previous sort
+        "DESC";
+        const bpWidth = referenceFrame.toBP(2.5);
+
+        const sortHandler = sort => {
+          const viewport = clickState.viewport;
+          const features = viewport.getCachedFeatures();
+          this.sortSamples(sort.chr, sort.start, sort.end, sort.direction, features);
+        };
+
+        const sortLabel = this.type === 'seg' ? 'Sort by value' : 'Sort by type';
+        return [{
+          label: sortLabel,
+          click: e => {
+            const sort = {
+              direction: sortDirection,
+              chr: clickState.viewport.referenceFrame.chr,
+              start: genomicLocation - bpWidth,
+              end: genomicLocation + bpWidth
+            };
+            sortHandler(sort);
+            this.config.sort = sort;
+          }
+        }];
+      }
+
+      supportsWholeGenome() {
+        return (this.config.indexed === false || !this.config.indexURL) && this.config.supportsWholeGenome !== false;
+      }
+
+      updateSampleKeys(featureList) {
+        if (this.explicitSamples) return;
+
+        for (let feature of featureList) {
+          const sampleKey = feature.sampleKey || feature.sample;
+
+          if (!this.sampleNames.has(sampleKey)) {
+            this.sampleNames.set(sampleKey, feature.sample);
+            this.sampleKeys.push(sampleKey);
+          }
+        }
+      }
+
+    } // Mut and MAF file default color table
+
+
+    const MUT_COLORS = {
+      "indel": "rgb(0,200,0)",
+      "targeted region": "rgb(236,155,43)",
+      "truncating": "rgb(	150,0,0)",
+      "non-coding transcript": "rgb(0,0,150)",
+      // Colors from https://www.nature.com/articles/nature11404
+      "synonymous": "rgb(109,165,95)",
+      "silent": "rgb(109,135,80)",
+      "missense_mutation": "rgb(72,130,187)",
+      "missense": "rgb(72,130,187)",
+      "splice site": "rgb(143,83,155)",
+      "splice_region": "rgb(143,83,155)",
+      "nonsense": "rgb(216, 57,81)",
+      "nonsense_mutation": "rgb(216, 57,81)",
+      "frame_shift_del": "rgb(226,135,65)",
+      "frame_shift_ins": "rgb(226,135,65)",
+      "in_frame_del": "rgb(247,235,94)",
+      "in_frame_ins": "rgb(247,235,94)",
+      "*other*": "rgb(159,91,50)" //
+      // 3'Flank
+      // 3'UTR
+      // 5'Flank
+      // 5'UTR
+      // Frame_Shift_Del
+      // Frame_Shift_Ins
+      // IGR
+      // In_Frame_Del
+      // In_Frame_Ins
+      // Intron
+      // Missense_Mutation
+      // Nonsense_Mutation
+      // Nonstop_Mutation
+      // RNA
+      // Silent
+      // Splice_Region
+      // Splice_Site
+      // Translation_Start_Site
+      // Variant_Classification
+
+    };
+
+    /*
+     * The MIT License (MIT)
+     *
+     * Copyright (c) 2016-2017 The Regents of the University of California
+     * Author: Jim Robinson
+     *
+     * Permission is hereby granted, free of charge, to any person obtaining a copy
+     * of this software and associated documentation files (the "Software"), to deal
+     * in the Software without restriction, including without limitation the rights
+     * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+     * copies of the Software, and to permit persons to whom the Software is
+     * furnished to do so, subject to the following conditions:
+     *
+     * The above copyright notice and this permission notice shall be included in
+     * all copies or substantial portions of the Software.
+     *
+     *
+     * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+     * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+     * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+     * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+     * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+     * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+     * THE SOFTWARE.
+     */
+
+    class MergedTrack extends TrackBase {
+      constructor(config, browser) {
+        super(config, browser);
+      }
+
+      init(config) {
+        if (!config.tracks) {
+          throw Error("Error: no tracks defined for merged track" + config);
+        }
+
+        super.init(config);
+      }
+
+      async postInit() {
+        this.tracks = [];
+
+        for (let tconf of this.config.tracks) {
+          if (!tconf.type) inferTrackType(tconf);
+          tconf.isMergedTrack = true;
+          const t = await this.browser.createTrack(tconf);
+
+          if (t) {
+            t.autoscale = false; // Scaling done from merged track
+
+            this.tracks.push(t);
+          } else {
+            console.warn("Could not create track " + tconf);
+          }
+        }
+
+        Object.defineProperty(this, "height", {
+          get() {
+            return this._height;
+          },
+
+          set(h) {
+            this._height = h;
+
+            for (let t of this.tracks) {
+              t.height = h;
+              t.config.height = h;
+            }
+          }
+
+        });
+        this.height = this.config.height || 100;
+      }
+
+      async getFeatures(chr, bpStart, bpEnd, bpPerPixel) {
+        const promises = this.tracks.map(t => t.getFeatures(chr, bpStart, bpEnd, bpPerPixel));
+        return Promise.all(promises);
+      }
+
+      draw(options) {
+        var i, len, mergedFeatures, trackOptions, dataRange;
+        mergedFeatures = options.features; // Array of feature arrays, 1 for each track
+
+        dataRange = autoscale(options.referenceFrame.chr, mergedFeatures); //IGVGraphics.fillRect(options.context, 0, options.pixelTop, options.pixelWidth, options.pixelHeight, {'fillStyle': "rgb(255, 255, 255)"});
+
+        for (i = 0, len = this.tracks.length; i < len; i++) {
+          trackOptions = Object.assign({}, options);
+          trackOptions.features = mergedFeatures[i];
+          this.tracks[i].dataRange = dataRange;
+          this.tracks[i].draw(trackOptions);
+        }
+      }
+
+      paintAxis(ctx, pixelWidth, pixelHeight) {
+        var i, len, autoscale, track;
+        autoscale = true; // Hardcoded for now
+
+        for (i = 0, len = this.tracks.length; i < len; i++) {
+          track = this.tracks[i];
+
+          if (typeof track.paintAxis === 'function') {
+            track.paintAxis(ctx, pixelWidth, pixelHeight);
+            if (autoscale) break;
+          }
+        }
+      }
+
+      popupData(clickState, features) {
+        const featuresArray = features || clickState.viewport.getCachedFeatures();
+
+        if (featuresArray && featuresArray.length === this.tracks.length) {
+          // Array of feature arrays, 1 for each track
+          const popupData = [];
+
+          for (let i = 0; i < this.tracks.length; i++) {
+            if (i > 0) popupData.push("<hr/>");
+            popupData.push(`<div style=background-color:#f7f8fa;border-bottom-style:dashed;border-bottom-width:1px;margin-bottom:5px;margin-top:5px;font-size:medium><b>${this.tracks[i].name}</b></div>`);
+            const trackPopupData = this.tracks[i].popupData(clickState, featuresArray[i]);
+            popupData.push(...trackPopupData);
+          }
+
+          return popupData;
+        }
+      }
+
+    }
+
+    function autoscale(chr, featureArrays) {
+      var min = 0,
+          max = -Number.MAX_VALUE;
+     // if (chr === 'all') {
+      //     allValues = [];
+      //     featureArrays.forEach(function (features) {
+      //         features.forEach(function (f) {
+      //             if (!Number.isNaN(f.value)) {
+      //                 allValues.push(f.value);
+      //             }
+      //         });
+      //     });
+      //
+      //     min = Math.min(0, IGVMath.percentile(allValues, .1));
+      //     max = IGVMath.percentile(allValues, 99.9);
+      //
+      // }
+      // else {
+
+      featureArrays.forEach(function (features, i) {
+        features.forEach(function (f) {
+          if (typeof f.value !== 'undefined' && !Number.isNaN(f.value)) {
+            min = Math.min(min, f.value);
+            max = Math.max(max, f.value);
+          }
+        });
+      }); //  }
+
+      return {
+        min: min,
+        max: max
+      };
+    }
+
+    /*
+     * The MIT License (MIT)
+     *
+     * Copyright (c) 2016 University of California San Diego
+     * Author: Jim Robinson
+     *
+     * Permission is hereby granted, free of charge, to any person obtaining a copy
+     * of this software and associated documentation files (the "Software"), to deal
+     * in the Software without restriction, including without limitation the rights
+     * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+     * copies of the Software, and to permit persons to whom the Software is
+     * furnished to do so, subject to the following conditions:
+     *
+     * The above copyright notice and this permission notice shall be included in
+     * all copies or substantial portions of the Software.
+     *
+     *
+     * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+     * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+     * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+     * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+     * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+     * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+     * THE SOFTWARE.
+     */
+    class PairedAlignment {
+      constructor(firstAlignment) {
+        this.paired = true;
+        this.firstAlignment = firstAlignment;
+        this.chr = firstAlignment.chr;
+        this.readName = firstAlignment.readName;
+
+        if (firstAlignment.start < firstAlignment.mate.position) {
+          this.start = firstAlignment.start;
+          this.scStart = firstAlignment.scStart;
+          this.connectingStart = firstAlignment.start + firstAlignment.lengthOnRef;
+          this.connectingEnd = firstAlignment.mate.position;
+        } else {
+          this.start = firstAlignment.mate.position;
+          this.scStart = this.start;
+          this.connectingStart = firstAlignment.mate.position;
+          this.connectingEnd = firstAlignment.start;
+        }
+
+        this.end = Math.max(firstAlignment.mate.position, firstAlignment.start + firstAlignment.lengthOnRef); // Approximate
+
+        this.lengthOnRef = this.end - this.start;
+        let scEnd = Math.max(this.end, firstAlignment.scStart + firstAlignment.scLengthOnRef);
+        this.scLengthOnRef = scEnd - this.scStart;
+      }
+
+      setSecondAlignment(secondAlignment) {
+        // TODO -- check the chrs are equal,  error otherwise
+        this.secondAlignment = secondAlignment;
+        const firstAlignment = this.firstAlignment;
+
+        if (secondAlignment.start > firstAlignment.start) {
+          this.connectingEnd = secondAlignment.start;
+        } else {
+          this.connectingStart = secondAlignment.start + secondAlignment.lengthOnRef;
+        }
+
+        this.start = Math.min(firstAlignment.start, secondAlignment.start);
+        this.end = Math.max(firstAlignment.start + firstAlignment.lengthOnRef, secondAlignment.start + secondAlignment.lengthOnRef);
+        this.lengthOnRef = this.end - this.start;
+        this.scStart = Math.min(firstAlignment.scStart, secondAlignment.scStart);
+        const scEnd = Math.max(firstAlignment.scStart + firstAlignment.scLengthOnRef, secondAlignment.scStart + secondAlignment.scLengthOnRef);
+        this.scLengthOnRef = scEnd - this.scStart;
+      }
+
+      containsLocation(genomicLocation, showSoftClips) {
+        const s = showSoftClips ? this.scStart : this.start;
+        const l = showSoftClips ? this.scLengthOnRef : this.lengthOnRef;
+        return genomicLocation >= s && genomicLocation <= s + l;
+      }
+
+      alignmentContaining(genomicLocation, showSoftClips) {
+        if (this.firstAlignment.containsLocation(genomicLocation, showSoftClips)) {
+          return this.firstAlignment;
+        } else if (this.secondAlignment && this.secondAlignment.containsLocation(genomicLocation, showSoftClips)) {
+          return this.secondAlignment;
+        } else {
+          return undefined;
+        }
+      }
+
+      popupData(genomicLocation) {
+        let nameValues = this.firstAlignment.popupData(genomicLocation);
+
+        if (this.secondAlignment) {
+          nameValues.push("-------------------------------");
+          nameValues = nameValues.concat(this.secondAlignment.popupData(genomicLocation));
+        }
+
+        return nameValues;
+      }
+
+      isPaired() {
+        return true; // By definition
+      }
+
+      firstOfPairStrand() {
+        if (this.firstAlignment.isFirstOfPair()) {
+          return this.firstAlignment.strand;
+        } else if (this.secondAlignment && this.secondAlignment.isFirstOfPair()) {
+          return this.secondAlignment.strand;
+        } else {
+          return this.firstAlignment.mate.strand; // Assumption is mate is first-of-pair
+        }
+      }
+
+    }
+
+    /*
+     * The MIT License (MIT)
+     *
+     * Copyright (c) 2014 Broad Institute
+     *
+     * Permission is hereby granted, free of charge, to any person obtaining a copy
+     * of this software and associated documentation files (the "Software"), to deal
+     * in the Software without restriction, including without limitation the rights
+     * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+     * copies of the Software, and to permit persons to whom the Software is
+     * furnished to do so, subject to the following conditions:
+     *
+     * The above copyright notice and this permission notice shall be included in
+     * all copies or substantial portions of the Software.
+     *
+     *
+     * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+     * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+     * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+     * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+     * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+     * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+     * THE SOFTWARE.
+     */
+    const isString$3 = isString$6;
+    const hashCode = hashCode$1;
+
+    class BamAlignmentRow {
+      constructor() {
+        this.alignments = [];
+        this.score = undefined;
+      }
+
+      findAlignment(genomicLocation) {
+        const alignmentContains = (a, genomicLocation) => {
+          return genomicLocation >= a.start && genomicLocation < a.start + a.lengthOnRef;
+        }; // find single alignment that overlaps sort location
+
+
+        let centerAlignment;
+
+        for (let i = 0; i < this.alignments.length; i++) {
+          const a = this.alignments[i];
+
+          if (genomicLocation >= a.start && genomicLocation < a.start + a.lengthOnRef) {
+            if (a.paired) {
+              if (a.firstAlignment && alignmentContains(a.firstAlignment, genomicLocation)) {
+                centerAlignment = a.firstAlignment;
+              } else if (a.secondAlignment && alignmentContains(a.secondAlignment, genomicLocation)) {
+                centerAlignment = a.secondAlignment;
+              }
+            } else {
+              centerAlignment = a;
+            }
+
+            break;
+          }
+        }
+
+        return centerAlignment;
+      }
+
+      updateScore(options, alignmentContainer) {
+        this.score = this.calculateScore(options, alignmentContainer);
+      }
+
+      calculateScore({
+        position,
+        option,
+        direction,
+        tag
+      }, alignmentContainer) {
+        if (!option) option = "BASE";
+        const alignment = this.findAlignment(position);
+
+        if (undefined === alignment) {
+          return Number.MAX_VALUE * (direction ? 1 : -1);
+        }
+
+        let mate;
+
+        switch (option) {
+          case "NUCLEOTIDE":
+          case "BASE":
+            {
+              return calculateBaseScore(alignment, alignmentContainer, position);
+            }
+
+          case "STRAND":
+            return alignment.strand ? 1 : -1;
+
+          case "START":
+            return alignment.start;
+
+          case "TAG":
+            {
+              const tagValue = alignment.tags()[tag];
+
+              if (tagValue !== undefined) {
+                return isString$3(tagValue) ? hashCode(tagValue) : tagValue;
+              } else {
+                return Number.MAX_VALUE;
+              }
+            }
+
+          case "READ_NAME":
+            return hashCode(alignment.readName);
+
+          case "INSERT_SIZE":
+            return -Math.abs(alignment.fragmentLength);
+
+          case "GAP_SIZE":
+            return -alignment.gapSizeAt(position);
+
+          case "MATE_CHR":
+            mate = alignment.mate;
+
+            if (!mate) {
+              return Number.MAX_VALUE;
+            } else {
+              if (mate.chr === alignment.chr) {
+                return Number.MAX_VALUE - 1;
+              } else {
+                return hashCode(mate.chr);
+              }
+            }
+
+          case "MQ":
+            return alignment.mq === undefined ? Number.MAX_VALUE : -alignment.mq;
+
+          default:
+            return Number.MAX_VALUE;
+        }
+
+        function calculateBaseScore(alignment, alignmentContainer, genomicLocation) {
+          let reference;
+          const idx = Math.floor(genomicLocation) - alignmentContainer.start;
+
+          if (idx < alignmentContainer.sequence.length) {
+            reference = alignmentContainer.sequence.charAt(idx);
+          }
+
+          if (!reference) {
+            return 0;
+          }
+
+          const base = alignment.readBaseAt(genomicLocation);
+          const quality = alignment.readBaseQualityAt(genomicLocation);
+          const coverageMap = alignmentContainer.coverageMap;
+          const coverageMapIndex = Math.floor(genomicLocation - coverageMap.bpStart);
+          const coverage = coverageMap.coverage[coverageMapIndex]; // Insertions.  These are additive with base scores as they occur between bases, so you can have a
+          // base mismatch AND an insertion
+
+          let baseScore = 0;
+
+          if (alignment.insertions) {
+            for (let ins of alignment.insertions) {
+              if (ins.start === genomicLocation) {
+                baseScore = -coverage.ins;
+              }
+            }
+          }
+
+          if (!base) {
+            // Either deletion or skipped (splice junction)
+            const delCount = coverage.del;
+
+            if (delCount > 0) {
+              baseScore -= delCount;
+            } else if (baseScore === 0) {
+              // Don't modify insertion score, if any
+              baseScore = 1;
+            }
+          } else {
+            reference = reference.toUpperCase();
+
+            if ('N' === base && baseScore === 0) {
+              baseScore = 2;
+            } else if ((reference === base || '=' === base) && baseScore === 0) {
+              baseScore = 4 - quality / 1000;
+            } else if ("X" === base || reference !== base) {
+              const count = coverage["pos" + base] + coverage["neg" + base];
+              baseScore -= count + quality / 1000;
+            }
+          }
+
+          return baseScore;
+        }
+      }
+
+    }
+
+    function canBePaired(alignment) {
+      return alignment.isPaired() && alignment.mate && alignment.isMateMapped() && alignment.chr === alignment.mate.chr && (alignment.isFirstOfPair() || alignment.isSecondOfPair()) && !(alignment.isSecondary() || alignment.isSupplementary());
+    }
+
+    function pairAlignments(rows) {
+      const pairCache = {};
+      const result = [];
+
+      for (let row of rows) {
+        for (let alignment of row.alignments) {
+          if (canBePaired(alignment)) {
+            let pairedAlignment = pairCache[alignment.readName];
+
+            if (pairedAlignment) {
+              pairedAlignment.setSecondAlignment(alignment);
+              pairCache[alignment.readName] = undefined; // Don't need to track this anymore.
+            } else {
+              pairedAlignment = new PairedAlignment(alignment);
+              pairCache[alignment.readName] = pairedAlignment;
+              result.push(pairedAlignment);
+            }
+          } else {
+            result.push(alignment);
+          }
+        }
+      }
+
+      return result;
+    }
+
+    function unpairAlignments(rows) {
+      const result = [];
+
+      for (let row of rows) {
+        for (let alignment of row.alignments) {
+          if (alignment instanceof PairedAlignment) {
+            if (alignment.firstAlignment) result.push(alignment.firstAlignment); // shouldn't need the null test
+
+            if (alignment.secondAlignment) result.push(alignment.secondAlignment);
+          } else {
+            result.push(alignment);
+          }
+        }
+      }
+
+      return result;
+    }
+
+    function packAlignmentRows(alignments, start, end, showSoftClips) {
+      if (!alignments) {
+        return undefined;
+      } else if (alignments.length === 0) {
+        return [];
+      } else {
+        alignments.sort(function (a, b) {
+          return showSoftClips ? a.scStart - b.scStart : a.start - b.start;
+        }); // bucketStart = Math.max(start, alignments[0].start);
+
+        const firstAlignment = alignments[0];
+        let bucketStart = Math.max(start, showSoftClips ? firstAlignment.scStart : firstAlignment.start);
+        let nextStart = bucketStart;
+        const bucketList = [];
+
+        for (let alignment of alignments) {
+          //var buckListIndex = Math.max(0, alignment.start - bucketStart);
+          const s = showSoftClips ? alignment.scStart : alignment.start;
+          const buckListIndex = Math.max(0, s - bucketStart);
+
+          if (bucketList[buckListIndex] === undefined) {
+            bucketList[buckListIndex] = [];
+          }
+
+          bucketList[buckListIndex].push(alignment);
+        }
+
+        let allocatedCount = 0;
+        let lastAllocatedCount = 0;
+        const packedAlignmentRows = [];
+        const alignmentSpace = 2;
+
+        try {
+          while (allocatedCount < alignments.length) {
+            const alignmentRow = new BamAlignmentRow();
+
+            while (nextStart <= end) {
+              let bucket = undefined;
+              let index;
+
+              while (!bucket && nextStart <= end) {
+                index = nextStart - bucketStart;
+
+                if (bucketList[index] === undefined) {
+                  ++nextStart; // No alignments at this index
+                } else {
+                  bucket = bucketList[index];
+                }
+              } // while (bucket)
+
+
+              if (!bucket) {
+                break;
+              }
+
+              const alignment = bucket.pop();
+
+              if (0 === bucket.length) {
+                bucketList[index] = undefined;
+              }
+
+              alignmentRow.alignments.push(alignment);
+              nextStart = showSoftClips ? alignment.scStart + alignment.scLengthOnRef + alignmentSpace : alignment.start + alignment.lengthOnRef + alignmentSpace;
+              ++allocatedCount;
+            } // while (nextStart)
+
+
+            if (alignmentRow.alignments.length > 0) {
+              packedAlignmentRows.push(alignmentRow);
+            }
+
+            nextStart = bucketStart;
+            if (allocatedCount === lastAllocatedCount) break; // Protect from infinite loops
+
+            lastAllocatedCount = allocatedCount;
+          } // while (allocatedCount)
+
+        } catch (e) {
+          console.error(e);
+          throw e;
+        }
+
+        return packedAlignmentRows;
+      }
+    }
+
+    /*
+     * The MIT License (MIT)
+     *
+     * Copyright (c) 2016 University of California San Diego
+     * Author: Jim Robinson
+     *
+     * Permission is hereby granted, free of charge, to any person obtaining a copy
+     * of this software and associated documentation files (the "Software"), to deal
+     * in the Software without restriction, including without limitation the rights
+     * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+     * copies of the Software, and to permit persons to whom the Software is
+     * furnished to do so, subject to the following conditions:
+     *
+     * The above copyright notice and this permission notice shall be included in
+     * all copies or substantial portions of the Software.
+     *
+     *
+     * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+     * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+     * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+     * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+     * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+     * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+     * THE SOFTWARE.
+     */
+
+    class AlignmentContainer {
+      constructor(chr, start, end, samplingWindowSize, samplingDepth, pairsSupported, alleleFreqThreshold) {
+        this.chr = chr;
+        this.start = Math.floor(start);
+        this.end = Math.ceil(end);
+        this.length = end - start;
+        this.alleleFreqThreshold = alleleFreqThreshold === undefined ? 0.2 : alleleFreqThreshold;
+        this.coverageMap = new CoverageMap(chr, start, end, this.alleleFreqThreshold);
+        this.alignments = [];
+        this.downsampledIntervals = [];
+        this.samplingWindowSize = samplingWindowSize === undefined ? 100 : samplingWindowSize;
+        this.samplingDepth = samplingDepth === undefined ? 1000 : samplingDepth;
+        this.pairsSupported = pairsSupported === undefined ? true : pairsSupported;
+        this.paired = false; // false until proven otherwise
+
+        this.pairsCache = {}; // working cache of paired alignments by read name
+
+        this.downsampledReads = new Set();
+        this.currentBucket = new DownsampleBucket(this.start, this.start + this.samplingWindowSize, this);
+
+        this.filter = function filter(alignment) {
+          // TODO -- pass this in
+          return alignment.isMapped() && !alignment.isFailsVendorQualityCheck();
+        };
+
+        this.pairedEndStats = new PairedEndStats();
+      }
+
+      push(alignment) {
+        if (this.filter(alignment) === false) return;
+
+        if (alignment.isPaired()) {
+          this.pairedEndStats.push(alignment);
+        }
+
+        this.coverageMap.incCounts(alignment); // Count coverage before any downsampling
+
+        if (this.pairsSupported && this.downsampledReads.has(alignment.readName)) {
+          return; // Mate already downsampled -- pairs are treated as a single alignment for downsampling
+        }
+
+        if (alignment.start >= this.currentBucket.end) {
+          this.finishBucket();
+          this.currentBucket = new DownsampleBucket(alignment.start, alignment.start + this.samplingWindowSize, this);
+        }
+
+        this.currentBucket.addAlignment(alignment);
+      }
+
+      forEach(callback) {
+        this.alignments.forEach(callback);
+      }
+
+      finish() {
+        if (this.currentBucket !== undefined) {
+          this.finishBucket();
+        }
+
+        this.alignments.sort(function (a, b) {
+          return a.start - b.start;
+        });
+        this.pairsCache = undefined;
+        this.downsampledReads = undefined;
+        this.pairedEndStats.compute();
+      }
+
+      contains(chr, start, end) {
+        return this.chr === chr && this.start <= start && this.end >= end;
+      }
+
+      hasDownsampledIntervals() {
+        return this.downsampledIntervals && this.downsampledIntervals.length > 0;
+      }
+
+      finishBucket() {
+        this.alignments = this.alignments.concat(this.currentBucket.alignments);
+
+        if (this.currentBucket.downsampledCount > 0) {
+          this.downsampledIntervals.push(new DownsampledInterval(this.currentBucket.start, this.currentBucket.end, this.currentBucket.downsampledCount));
+        }
+
+        this.paired = this.paired || this.currentBucket.paired;
+      }
+
+      setViewAsPairs(bool) {
+        let alignments;
+
+        if (bool) {
+          alignments = pairAlignments(this.packedAlignmentRows);
+        } else {
+          alignments = unpairAlignments(this.packedAlignmentRows);
+        }
+
+        this.packedAlignmentRows = packAlignmentRows(alignments, this.start, this.end);
+      }
+
+      setShowSoftClips(bool) {
+        const alignments = this.allAlignments();
+        this.packedAlignmentRows = packAlignmentRows(alignments, this.start, this.end, bool);
+      }
+
+      allAlignments() {
+        const alignments = [];
+
+        for (let row of this.packedAlignmentRows) {
+          for (let alignment of row.alignments) {
+            alignments.push(alignment);
+          }
+        }
+
+        return alignments;
+      }
+
+      getMax(start, end) {
+        return this.coverageMap.getMax(start, end);
+      }
+
+    }
+
+    class DownsampleBucket {
+      constructor(start, end, alignmentContainer) {
+        this.start = start;
+        this.end = end;
+        this.alignments = [];
+        this.downsampledCount = 0;
+        this.samplingDepth = alignmentContainer.samplingDepth;
+        this.pairsSupported = alignmentContainer.pairsSupported;
+        this.downsampledReads = alignmentContainer.downsampledReads;
+        this.pairsCache = alignmentContainer.pairsCache;
+      }
+
+      addAlignment(alignment) {
+        var idx, replacedAlignment, pairedAlignment;
+
+        if (this.pairsSupported && canBePaired(alignment)) {
+          pairedAlignment = this.pairsCache[alignment.readName];
+
+          if (pairedAlignment) {
+            // Not subject to downsampling, just update the existing alignment
+            pairedAlignment.setSecondAlignment(alignment);
+            this.pairsCache[alignment.readName] = undefined; // Don't need to track this anymore. NOTE: Don't "delete", causes runtime performance issues
+
+            return;
+          }
+        }
+
+        if (this.alignments.length < this.samplingDepth) {
+          if (this.pairsSupported && canBePaired(alignment)) {
+            // First alignment in a pair
+            pairedAlignment = new PairedAlignment(alignment);
+            this.paired = true;
+            this.pairsCache[alignment.readName] = pairedAlignment;
+            this.alignments.push(pairedAlignment);
+          } else {
+            this.alignments.push(alignment);
+          }
+        } else {
+          idx = Math.floor(Math.random() * (this.samplingDepth + this.downsampledCount - 1));
+
+          if (idx < this.samplingDepth) {
+            // Keep the new item
+            //  idx = Math.floor(Math.random() * (this.alignments.length - 1));
+            replacedAlignment = this.alignments[idx]; // To be replaced
+
+            if (this.pairsSupported && canBePaired(alignment)) {
+              if (this.pairsCache[replacedAlignment.readName] !== undefined) {
+                this.pairsCache[replacedAlignment.readName] = undefined;
+              }
+
+              pairedAlignment = new PairedAlignment(alignment);
+              this.paired = true;
+              this.pairsCache[alignment.readName] = pairedAlignment;
+              this.alignments[idx] = pairedAlignment;
+            } else {
+              this.alignments[idx] = alignment;
+            }
+
+            this.downsampledReads.add(replacedAlignment.readName);
+          } else {
+            this.downsampledReads.add(alignment.readName);
+          }
+
+          this.downsampledCount++;
+        }
+      }
+
+    }
+
+    class CoverageMap {
+      constructor(chr, start, end, alleleFreqThreshold) {
+        this.chr = chr;
+        this.bpStart = start;
+        this.length = end - start;
+        this.coverage = new Array(this.length);
+        this.maximum = 0;
+        this.threshold = alleleFreqThreshold;
+        this.qualityWeight = true;
+      }
+      /**
+       * Return the maximum coverage value between start and end.  This is used for autoscaling.
+       * @param start
+       * @param end
+       */
+
+
+      getMax(start, end) {
+        let max = 0;
+        const len = this.coverage.length;
+
+        for (let i = 0; i < len; i++) {
+          const pos = this.bpStart + i;
+          if (pos > end) break;
+          const cov = this.coverage[i];
+
+          if (pos >= start && cov) {
+            max = Math.max(max, cov.total);
+          }
+        }
+
+        return max;
+      }
+
+      incCounts(alignment) {
+        var self = this;
+
+        if (alignment.blocks === undefined) {
+          incBlockCount(alignment);
+        } else {
+          alignment.blocks.forEach(function (block) {
+            incBlockCount(block);
+          });
+        }
+
+        if (alignment.gaps) {
+          for (let del of alignment.gaps) {
+            if (del.type === 'D') {
+              const offset = del.start - self.bpStart;
+
+              for (let i = offset; i < offset + del.len; i++) {
+                if (i < 0) continue;
+
+                if (!this.coverage[i]) {
+                  this.coverage[i] = new Coverage(self.threshold);
+                }
+
+                this.coverage[i].del++;
+              }
+            }
+          }
+        }
+
+        if (alignment.insertions) {
+          for (let del of alignment.insertions) {
+            const i = del.start - this.bpStart;
+            if (i < 0) continue;
+
+            if (!this.coverage[i]) {
+              this.coverage[i] = new Coverage(self.threshold);
+            }
+
+            this.coverage[i].ins++;
+          }
+        }
+
+        function incBlockCount(block) {
+          if ('S' === block.type) return;
+          const seq = alignment.seq;
+          const qual = alignment.qual;
+          const seqOffset = block.seqOffset;
+
+          for (let i = block.start - self.bpStart, j = 0; j < block.len; i++, j++) {
+            if (!self.coverage[i]) {
+              self.coverage[i] = new Coverage(self.threshold);
+            }
+
+            const base = seq == undefined ? "N" : seq.charAt(seqOffset + j);
+            const key = alignment.strand ? "pos" + base : "neg" + base;
+            const q = qual && seqOffset + j < qual.length ? qual[seqOffset + j] : 30;
+            self.coverage[i][key] += 1;
+            self.coverage[i]["qual" + base] += q;
+            self.coverage[i].total += 1;
+            self.coverage[i].qual += q;
+            self.maximum = Math.max(self.coverage[i].total, self.maximum);
+          }
+        }
+      }
+
+    }
+
+    class Coverage {
+      constructor(alleleThreshold) {
+        this.qualityWeight = true;
+        this.posA = 0;
+        this.negA = 0;
+        this.posT = 0;
+        this.negT = 0;
+        this.posC = 0;
+        this.negC = 0;
+        this.posG = 0;
+        this.negG = 0;
+        this.posN = 0;
+        this.negN = 0;
+        this.pos = 0;
+        this.neg = 0;
+        this.qualA = 0;
+        this.qualT = 0;
+        this.qualC = 0;
+        this.qualG = 0;
+        this.qualN = 0;
+        this.qual = 0;
+        this.total = 0;
+        this.del = 0;
+        this.ins = 0;
+        this.threshold = alleleThreshold;
+      }
+
+      isMismatch(refBase) {
+        const threshold = this.threshold * (this.qualityWeight && this.qual ? this.qual : this.total);
+        let mismatchQualitySum = 0;
+
+        for (let base of ["A", "T", "C", "G"]) {
+          if (base !== refBase) {
+            mismatchQualitySum += this.qualityWeight && this.qual ? this["qual" + base] : this["pos" + base] + this["neg" + base];
+          }
+        }
+
+        return mismatchQualitySum >= threshold;
+      }
+
+    }
+
+    class DownsampledInterval {
+      constructor(start, end, counts) {
+        this.start = start;
+        this.end = end;
+        this.counts = counts;
+      }
+
+      popupData(genomicLocation) {
+        return [{
+          name: "start",
+          value: this.start + 1
+        }, {
+          name: "end",
+          value: this.end
+        }, {
+          name: "# downsampled:",
+          value: this.counts
+        }];
+      }
+
+    }
+
+    class PairedEndStats {
+      constructor(lowerPercentile, upperPercentile) {
+        this.totalCount = 0;
+        this.frCount = 0;
+        this.rfCount = 0;
+        this.ffCount = 0;
+        this.sumF = 0;
+        this.sumF2 = 0; //this.lp = lowerPercentile === undefined ? 0.005 : lowerPercentile;
+        //this.up = upperPercentile === undefined ? 0.995 : upperPercentile;
+        //this.digest = new Digest();
+      }
+
+      push(alignment) {
+        if (alignment.isProperPair()) {
+          var fragmentLength = Math.abs(alignment.fragmentLength); //this.digest.push(fragmentLength);
+
+          this.sumF += fragmentLength;
+          this.sumF2 += fragmentLength * fragmentLength;
+          var po = alignment.pairOrientation;
+
+          if (typeof po === "string" && po.length === 4) {
+            var tmp = '' + po.charAt(0) + po.charAt(2);
+
+            switch (tmp) {
+              case 'FF':
+              case 'RR':
+                this.ffCount++;
+                break;
+
+              case "FR":
+                this.frCount++;
+                break;
+
+              case "RF":
+                this.rfCount++;
+            }
+          }
+
+          this.totalCount++;
+        }
+      }
+
+      compute() {
+        if (this.totalCount > 100) {
+          if (this.ffCount / this.totalCount > 0.9) this.orienation = "ff";else if (this.frCount / this.totalCount > 0.9) this.orienation = "fr";else if (this.rfCount / this.totalCount > 0.9) this.orienation = "rf";
+          var fMean = this.sumF / this.totalCount;
+          var stdDev = Math.sqrt((this.totalCount * this.sumF2 - this.sumF * this.sumF) / (this.totalCount * this.totalCount));
+          this.lowerFragmentLength = fMean - 3 * stdDev;
+          this.upperFragmentLength = fMean + 3 * stdDev; //this.lowerFragmentLength = this.digest.percentile(this.lp);
+          //this.upperFragmentLength = this.digest.percentile(this.up);
+          //this.digest = undefined;
+        }
+      }
+
+    }
+
+    /*
+     * The MIT License (MIT)
+     *
+     * Copyright (c) 2014 Broad Institute
+     *
+     * Permission is hereby granted, free of charge, to any person obtaining a copy
+     * of this software and associated documentation files (the "Software"), to deal
+     * in the Software without restriction, including without limitation the rights
+     * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+     * copies of the Software, and to permit persons to whom the Software is
+     * furnished to do so, subject to the following conditions:
+     *
+     * The above copyright notice and this permission notice shall be included in
+     * all copies or substantial portions of the Software.
+     *
+     *
+     * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+     * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+     * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+     * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+     * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+     * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+     * THE SOFTWARE.
+     */
+    const READ_PAIRED_FLAG = 0x1;
+    const PROPER_PAIR_FLAG = 0x2;
+    const READ_UNMAPPED_FLAG = 0x4;
+    const MATE_UNMAPPED_FLAG = 0x8;
+    const READ_STRAND_FLAG$2 = 0x10;
+    const MATE_STRAND_FLAG$2 = 0x20;
+    const FIRST_OF_PAIR_FLAG = 0x40;
+    const SECOND_OF_PAIR_FLAG = 0x80;
+    const SECONDARY_ALIGNMNET_FLAG = 0x100;
+    const READ_FAILS_VENDOR_QUALITY_CHECK_FLAG = 0x200;
+    const DUPLICATE_READ_FLAG = 0x400;
+    const SUPPLEMENTARY_ALIGNMENT_FLAG = 0x800;
+    const ELEMENT_SIZE = {
+      c: 1,
+      C: 1,
+      s: 2,
+      S: 2,
+      i: 4,
+      I: 4,
+      f: 4
+    };
+    /**
+     * readName
+     * chr
+     * cigar
+     * lengthOnRef
+     * start
+     * seq
+     * qual
+     * mq
+     * strand
+     * blocks
+     */
+
+    class BamAlignment {
+      constructor() {
+        this.hidden = false;
+      }
+
+      isMapped() {
+        return (this.flags & READ_UNMAPPED_FLAG) === 0;
+      }
+
+      isPaired() {
+        return (this.flags & READ_PAIRED_FLAG) !== 0;
+      }
+
+      isProperPair() {
+        return (this.flags & PROPER_PAIR_FLAG) !== 0;
+      }
+
+      isFirstOfPair() {
+        return (this.flags & FIRST_OF_PAIR_FLAG) !== 0;
+      }
+
+      isSecondOfPair() {
+        return (this.flags & SECOND_OF_PAIR_FLAG) !== 0;
+      }
+
+      isSecondary() {
+        return (this.flags & SECONDARY_ALIGNMNET_FLAG) !== 0;
+      }
+
+      isSupplementary() {
+        return (this.flags & SUPPLEMENTARY_ALIGNMENT_FLAG) !== 0;
+      }
+
+      isFailsVendorQualityCheck() {
+        return (this.flags & READ_FAILS_VENDOR_QUALITY_CHECK_FLAG) !== 0;
+      }
+
+      isDuplicate() {
+        return (this.flags & DUPLICATE_READ_FLAG) !== 0;
+      }
+
+      isMateMapped() {
+        return (this.flags & MATE_UNMAPPED_FLAG) === 0;
+      }
+
+      isNegativeStrand() {
+        return (this.flags & READ_STRAND_FLAG$2) !== 0;
+      }
+
+      isMateNegativeStrand() {
+        return (this.flags & MATE_STRAND_FLAG$2) !== 0;
+      }
+
+      tags() {
+        if (!this.tagDict) {
+          if (this.tagBA) {
+            this.tagDict = decodeTags(this.tagBA);
+            this.tagBA = undefined;
+          } else {
+            this.tagDict = {}; // Mark so we don't try again.  The record has no tags
+          }
+        }
+
+        return this.tagDict;
+
+        function decodeTags(ba) {
+          let p = 0;
+          const len = ba.length;
+          const tags = {};
+
+          while (p < len) {
+            const tag = String.fromCharCode(ba[p]) + String.fromCharCode(ba[p + 1]);
+            p += 2;
+            const type = String.fromCharCode(ba[p++]);
+            let value;
+
+            if (type === 'A') {
+              value = String.fromCharCode(ba[p]);
+              p++;
+            } else if (type === 'i' || type === 'I') {
+              value = readInt$1(ba, p);
+              p += 4;
+            } else if (type === 'c') {
+              value = readInt8(ba, p);
+              p++;
+            } else if (type === 'C') {
+              value = readUInt8(ba, p);
+              p++;
+            } else if (type === 's' || type === 'S') {
+              value = readShort(ba, p);
+              p += 2;
+            } else if (type === 'f') {
+              value = readFloat(ba, p);
+              p += 4;
+            } else if (type === 'Z') {
+              value = '';
+
+              for (;;) {
+                var cc = ba[p++];
+
+                if (cc === 0) {
+                  break;
+                } else {
+                  value += String.fromCharCode(cc);
+                }
+              }
+            } else if (type === 'B') {
+              const elementType = String.fromCharCode(ba[p++]);
+              let elementSize = ELEMENT_SIZE[elementType];
+
+              if (elementSize === undefined) {
+                tags[tag] = `Error: unknown element type '${elementType}'`;
+                break;
+              }
+
+              const numElements = readInt$1(ba, p);
+              p += 4 + numElements * elementSize;
+              value = '[not shown]';
+            } else {
+              //'Unknown type ' + type;
+              value = 'Error unknown type: ' + type;
+              tags[tag] = value;
+              break;
+            }
+
+            tags[tag] = value;
+          }
+
+          return tags;
+        }
+      }
+      /**
+       * Does alignment (or alignment extended by soft clips) contain the genomic location?
+       *
+       * @param genomicLocation
+       * @param showSoftClips
+       * @returns {boolean|boolean}
+       */
+
+
+      containsLocation(genomicLocation, showSoftClips) {
+        const s = showSoftClips ? this.scStart : this.start;
+        const l = showSoftClips ? this.scLengthOnRef : this.lengthOnRef;
+        return genomicLocation >= s && genomicLocation <= s + l;
+      }
+
+      popupData(genomicLocation) {
+        // if the user clicks on a base next to an insertion, show just the
+        // inserted bases in a popup (like in desktop IGV).
+        const nameValues = []; // Consert genomic location to int
+
+        genomicLocation = Math.floor(genomicLocation);
+
+        if (this.insertions) {
+          const seq = this.seq;
+
+          for (let insertion of this.insertions) {
+            var ins_start = insertion.start;
+
+            if (genomicLocation === ins_start || genomicLocation === ins_start - 1) {
+              nameValues.push({
+                name: 'Insertion',
+                value: seq.substr(insertion.seqOffset, insertion.len)
+              });
+              nameValues.push({
+                name: 'Location',
+                value: ins_start
+              });
+              return nameValues;
+            }
+          }
+        }
+
+        nameValues.push({
+          name: 'Read Name',
+          value: this.readName
+        }); // Sample
+        // Read group
+
+        nameValues.push("<hr>"); // Add 1 to genomic location to map from 0-based computer units to user-based units
+
+        nameValues.push({
+          name: 'Alignment Start',
+          value: numberFormatter$1(1 + this.start),
+          borderTop: true
+        });
+        nameValues.push({
+          name: 'Read Strand',
+          value: true === this.strand ? '(+)' : '(-)',
+          borderTop: true
+        });
+        nameValues.push({
+          name: 'Cigar',
+          value: this.cigar
+        });
+        nameValues.push({
+          name: 'Mapped',
+          value: yesNo(this.isMapped())
+        });
+        nameValues.push({
+          name: 'Mapping Quality',
+          value: this.mq
+        });
+        nameValues.push({
+          name: 'Secondary',
+          value: yesNo(this.isSecondary())
+        });
+        nameValues.push({
+          name: 'Supplementary',
+          value: yesNo(this.isSupplementary())
+        });
+        nameValues.push({
+          name: 'Duplicate',
+          value: yesNo(this.isDuplicate())
+        });
+        nameValues.push({
+          name: 'Failed QC',
+          value: yesNo(this.isFailsVendorQualityCheck())
+        });
+
+        if (this.isPaired()) {
+          nameValues.push("<hr>");
+          nameValues.push({
+            name: 'First in Pair',
+            value: !this.isSecondOfPair(),
+            borderTop: true
+          });
+          nameValues.push({
+            name: 'Mate is Mapped',
+            value: yesNo(this.isMateMapped())
+          });
+
+          if (this.pairOrientation) {
+            nameValues.push({
+              name: 'Pair Orientation',
+              value: this.pairOrientation
+            });
+          }
+
+          if (this.isMateMapped()) {
+            nameValues.push({
+              name: 'Mate Chromosome',
+              value: this.mate.chr
+            });
+            nameValues.push({
+              name: 'Mate Start',
+              value: this.mate.position + 1
+            });
+            nameValues.push({
+              name: 'Mate Strand',
+              value: true === this.mate.strand ? '(+)' : '(-)'
+            });
+            nameValues.push({
+              name: 'Insert Size',
+              value: this.fragmentLength
+            }); // Mate Start
+            // Mate Strand
+            // Insert Size
+          } // First in Pair
+          // Pair Orientation
+
+        }
+
+        nameValues.push("<hr>");
+        const tagDict = this.tags();
+        let isFirst = true;
+
+        for (let key in tagDict) {
+          if (tagDict.hasOwnProperty(key)) {
+            if (isFirst) {
+              nameValues.push({
+                name: key,
+                value: tagDict[key],
+                borderTop: true
+              });
+              isFirst = false;
+            } else {
+              nameValues.push({
+                name: key,
+                value: tagDict[key]
+              });
+            }
+          }
+        }
+
+        nameValues.push("<hr>");
+        nameValues.push({
+          name: 'Genomic Location: ',
+          value: numberFormatter$1(1 + genomicLocation)
+        });
+        nameValues.push({
+          name: 'Read Base:',
+          value: this.readBaseAt(genomicLocation)
+        });
+        nameValues.push({
+          name: 'Base Quality:',
+          value: this.readBaseQualityAt(genomicLocation)
+        });
+        return nameValues;
+
+        function yesNo(bool) {
+          return bool ? 'Yes' : 'No';
+        }
+      }
+
+      readBaseAt(genomicLocation) {
+        const block = blockAtGenomicLocation(this.blocks, genomicLocation);
+
+        if (block) {
+          if ("*" === this.seq) {
+            return "*";
+          } else {
+            const idx = block.seqIndexAt(genomicLocation); // if (idx >= 0 && idx < this.seq.length) {
+
+            return this.seq[idx]; //  }
+          }
+        } else {
+          return undefined;
+        }
+      }
+
+      readBaseQualityAt(genomicLocation) {
+        const block = blockAtGenomicLocation(this.blocks, genomicLocation);
+
+        if (block) {
+          if ("*" === this.qual) {
+            return 30;
+          } else {
+            const idx = block.seqIndexAt(genomicLocation);
+
+            if (idx >= 0 && this.qual && idx < this.qual.length) {
+              return this.qual[idx];
+            } else {
+              return 30;
+            }
+          }
+        } else {
+          return undefined;
+        }
+      }
+
+      gapSizeAt(genomicLocation) {
+        if (this.gaps) {
+          for (let gap of this.gaps) {
+            if (genomicLocation >= gap.start && genomicLocation < gap.start + gap.len) {
+              return gap.len;
+            }
+          }
+        }
+
+        return 0;
+      }
+
+    }
+
+    function blockAtGenomicLocation(blocks, genomicLocation) {
+      for (let i = 0; i < blocks.length; i++) {
+        const block = blocks[i];
+
+        if (genomicLocation >= block.start && genomicLocation < block.start + block.len) {
+          return block;
+        }
+      }
+
+      return undefined;
+    }
+
+    function readInt$1(ba, offset) {
+      return ba[offset + 3] << 24 | ba[offset + 2] << 16 | ba[offset + 1] << 8 | ba[offset];
+    }
+
+    function readShort(ba, offset) {
+      return ba[offset + 1] << 8 | ba[offset];
+    }
+
+    function readFloat(ba, offset) {
+      const dataView = new DataView(ba.buffer);
+      return dataView.getFloat32(offset);
+    }
+
+    function readInt8(ba, offset) {
+      const dataView = new DataView(ba.buffer);
+      return dataView.getInt8(offset);
+    }
+
+    function readUInt8(ba, offset) {
+      const dataView = new DataView(ba.buffer);
+      return dataView.getUint8(offset);
+    }
+
+    /*
+     * The MIT License (MIT)
+     *
+     * Copyright (c) 2016-2017 The Regents of the University of California
+     * Author: Jim Robinson
+     *
+     * Permission is hereby granted, free of charge, to any person obtaining a copy
+     * of this software and associated documentation files (the "Software"), to deal
+     * in the Software without restriction, including without limitation the rights
+     * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+     * copies of the Software, and to permit persons to whom the Software is
+     * furnished to do so, subject to the following conditions:
+     *
+     * The above copyright notice and this permission notice shall be included in
+     * all copies or substantial portions of the Software.
+     *
+     *
+     * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+     * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+     * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+     * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+     * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+     * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+     * THE SOFTWARE.
+     */
+
+    /**
+     * Created by jrobinso on 4/5/18.
+     */
+    class AlignmentBlock {
+      constructor(b) {
+        if (b) {
+          Object.assign(this, b);
+        }
+      }
+
+      seqIndexAt(genomicLocation) {
+        return Math.floor(genomicLocation) - this.start + this.seqOffset;
+      }
+
+    }
+
+    class BamFilter {
+      constructor(options) {
+        if (!options) options = {};
+        this.vendorFailed = options.vendorFailed === undefined ? true : options.vendorFailed;
+        this.duplicates = options.duplicates === undefined ? true : options.duplicates;
+        this.secondary = options.secondary || false;
+        this.supplementary = options.supplementary || false;
+        this.mqThreshold = options.mqThreshold === undefined ? 0 : options.mqThreshold;
+
+        if (options.readgroups) {
+          this.readgroups = new Set(options.readgroups);
+        }
+      }
+
+      pass(alignment) {
+        if (this.vendorFailed && alignment.isFailsVendorQualityCheck()) return false;
+        if (this.duplicates && alignment.isDuplicate()) return false;
+        if (this.secondary && alignment.isSecondary()) return false;
+        if (this.supplementary && alignment.isSupplementary()) return false;
+        if (alignment.mq < this.mqThreshold) return false;
+
+        if (this.readgroups) {
+          var rg = alignment.tags()['RG'];
+          return this.readgroups.has(rg);
+        }
+
+        return true;
+      }
+
+    }
+
+    /**
+     * This code is based on the Biodalliance BAM reader by Thomas Down,  2011
+     *
+     * https://github.com/dasmoth/dalliance/blob/master/js/bam.js
+     */
+
+    const SEQ_DECODER = ['=', 'A', 'C', 'x', 'G', 'x', 'x', 'x', 'T', 'x', 'x', 'x', 'x', 'x', 'x', 'N'];
+    const CIGAR_DECODER = ['M', 'I', 'D', 'N', 'S', 'H', 'P', '=', 'X', '?', '?', '?', '?', '?', '?', '?'];
+    const READ_STRAND_FLAG$1 = 0x10;
+    const MATE_STRAND_FLAG$1 = 0x20;
+    const BAM1_MAGIC_BYTES = new Uint8Array([0x42, 0x41, 0x4d, 0x01]); // BAM\1
+
+    const BAM1_MAGIC_NUMBER = readInt(BAM1_MAGIC_BYTES, 0);
+    const DEFAULT_ALLELE_FREQ_THRESHOLD = 0.2;
+    const DEFAULT_SAMPLING_WINDOW_SIZE = 100;
+    const DEFAULT_SAMPLING_DEPTH = 500;
+    const MAXIMUM_SAMPLING_DEPTH = 10000;
+    const BamUtils = {
+      readHeader: function (url, options, genome) {
+        return igvxhr.loadArrayBuffer(url, options).then(function (compressedBuffer) {
+          var header, unc, uncba;
+          unc = unbgzf(compressedBuffer);
+          uncba = unc;
+          header = BamUtils.decodeBamHeader(uncba, genome);
+          return header;
+        });
+      },
+
+      /**
+       *
+       * @param ba  bytes to decode as a UInt8Array
+       * @param genome  optional igv genome object
+       * @returns {{ magicNumer: number, size: number, chrNames: Array, chrToIndex: ({}|*), chrAliasTable: ({}|*) }}
+       */
+      decodeBamHeader: function (ba, genome) {
+        var magic, samHeaderLen, samHeader, chrToIndex, chrNames, chrAliasTable, alias;
+        magic = readInt(ba, 0);
+
+        if (magic !== BAM1_MAGIC_NUMBER) {
+          throw new Error('BAM header errror: bad magic number.  This could be caused by either a corrupt or missing file.');
+        }
+
+        samHeaderLen = readInt(ba, 4);
+        samHeader = '';
+
+        for (var i = 0; i < samHeaderLen; ++i) {
+          samHeader += String.fromCharCode(ba[i + 8]);
+        }
+
+        var nRef = readInt(ba, samHeaderLen + 8);
+        var p = samHeaderLen + 12;
+        chrToIndex = {};
+        chrNames = [];
+        chrAliasTable = {};
+
+        for (i = 0; i < nRef; ++i) {
+          var lName = readInt(ba, p);
+          var name = '';
+
+          for (var j = 0; j < lName - 1; ++j) {
+            name += String.fromCharCode(ba[p + 4 + j]);
+          }
+
+          readInt(ba, p + lName + 4); //dlog(name + ': ' + lRef);
+
+          chrToIndex[name] = i;
+          chrNames[i] = name;
+
+          if (genome) {
+            alias = genome.getChromosomeName(name);
+            chrAliasTable[alias] = name;
+          }
+
+          p = p + 8 + lName;
+        }
+
+        return {
+          magicNumber: magic,
+          size: p,
+          chrNames: chrNames,
+          chrToIndex: chrToIndex,
+          chrAliasTable: chrAliasTable
+        };
+      },
+      bam_tag2cigar: function (ba, block_end, seq_offset, lseq, al, cigarArray) {
+        function type2size(x) {
+          if (x === 'C' || x === 'c' || x === 'A') return 1;else if (x === 'S' || x === 's') return 2;else if (x === 'I' || x === 'i' || x === 'f') return 4;else return 0;
+        } // test if the real CIGAR is encoded in a CG:B,I tag
+
+
+        if (cigarArray.length !== 1 || al.start < 0) return false;
+        var p = seq_offset + (lseq + 1 >> 1) + lseq;
+
+        while (p + 4 < block_end) {
+          var tag = String.fromCharCode(ba[p]) + String.fromCharCode(ba[p + 1]);
+          if (tag === 'CG') break;
+          var type = String.fromCharCode(ba[p + 2]);
+
+          if (type === 'B') {
+            // the binary array type
+            type = String.fromCharCode(ba[p + 3]);
+            var size = type2size(type);
+            var len = readInt(ba, p + 4);
+            p += 8 + size * len;
+          } else if (type === 'Z' || type === 'H') {
+            // 0-terminated string
+            p += 3;
+
+            while (ba[p++] !== 0) {}
+          } else {
+            // other atomic types
+            p += 3 + type2size(type);
+          }
+        }
+
+        if (p >= block_end) return false; // no CG tag
+
+        if (String.fromCharCode(ba[p + 2]) !== 'B' || String.fromCharCode(ba[p + 3]) !== 'I') return false; // not of type B,I
+        // now we know the real CIGAR length and its offset in the binary array
+
+        var cigar_len = readInt(ba, p + 4);
+        var cigar_offset = p + 8; // 4 for "CGBI" and 4 for length
+
+        if (cigar_offset + cigar_len * 4 > block_end) return false; // out of bound
+        // decode CIGAR
+
+        var cigar = '';
+        var lengthOnRef = 0;
+        cigarArray.length = 0; // empty the old array
+
+        p = cigar_offset;
+
+        for (var k = 0; k < cigar_len; ++k, p += 4) {
+          var cigop = readInt(ba, p);
+          var opLen = cigop >> 4;
+          var opLtr = CIGAR_DECODER[cigop & 0xf];
+          if (opLtr === 'M' || opLtr === 'EQ' || opLtr === 'X' || opLtr === 'D' || opLtr === 'N' || opLtr === '=') lengthOnRef += opLen;
+          cigar = cigar + opLen + opLtr;
+          cigarArray.push({
+            len: opLen,
+            ltr: opLtr
+          });
+        } // update alignment record. We are not updating bin, as apparently it is not used.
+
+
+        al.cigar = cigar;
+        al.lengthOnRef = lengthOnRef;
+        return true;
+      },
+
+      /**
+       *
+       * @param ba                 bytes to decode as an UInt8Array
+       * @param offset             offset position of ba array to start decoding
+       * @param alignmentContainer container to receive the decoded alignments
+       * @param min                minimum genomic position
+       * @param max                maximum genomic position
+       * @param chrIdx             chromosome index
+       * @param chrNames            array of chromosome names
+       * @param filter             a BamFilter object
+       *
+       * @return true if we have moved beyond the right end of the genomic range.
+       */
+      decodeBamRecords: function (ba, offset, alignmentContainer, chrNames, chrIdx, min, max, filter) {
+        while (offset < ba.length) {
+          const blockSize = readInt(ba, offset);
+          const blockEnd = offset + blockSize + 4;
+          const alignment = new BamAlignment();
+          const refID = readInt(ba, offset + 4);
+          const pos = readInt(ba, offset + 8);
+
+          if (blockEnd > ba.length) {
+            return;
+          }
+
+          if (refID < 0) {
+            offset = blockEnd;
+            continue; // unmapped read
+          } else if (chrIdx !== undefined && (refID > chrIdx || pos > max)) {
+            return true; // off right edge, we're done
+          } else if (chrIdx !== undefined && refID < chrIdx) {
+            offset = blockEnd;
+            continue; // ref ID to left of start, not sure this is possible
+          }
+
+          const bin_mq_nl = readInt(ba, offset + 12);
+          const mq = (bin_mq_nl & 0xff00) >> 8;
+          const nl = bin_mq_nl & 0xff;
+          const flag_nc = readInt(ba, offset + 16);
+          const flag = (flag_nc & 0xffff0000) >> 16;
+          const nc = flag_nc & 0xffff;
+          const lseq = readInt(ba, offset + 20);
+          const mateChrIdx = readInt(ba, offset + 24);
+          const matePos = readInt(ba, offset + 28);
+          const tlen = readInt(ba, offset + 32);
+          let readName = [];
+
+          for (let j = 0; j < nl - 1; ++j) {
+            readName.push(String.fromCharCode(ba[offset + 36 + j]));
+          }
+
+          readName = readName.join('');
+          let lengthOnRef = 0;
+          let cigar = '';
+          let p = offset + 36 + nl;
+          const cigarArray = []; // concatenate M,=,EQ,and X
+
+          let lastCigRecord;
+
+          for (let c = 0; c < nc; ++c) {
+            var cigop = readInt(ba, p);
+            var opLen = cigop >> 4;
+            var opLtr = CIGAR_DECODER[cigop & 0xf];
+            if (opLtr === 'M' || opLtr === 'EQ' || opLtr === 'X' || opLtr === 'D' || opLtr === 'N' || opLtr === '=') lengthOnRef += opLen;
+            cigar = cigar + opLen + opLtr;
+            p += 4; // if(mOperators.has(opLtr) && mOperators.has(lastCigRecord.ltr)) {
+            //     lastCigRecord.len += opLen;
+            //     lastCigRecord.ltr = 'M'
+            // }
+            // else {
+
+            lastCigRecord = {
+              len: opLen,
+              ltr: opLtr
+            };
+            cigarArray.push(lastCigRecord); //}
+          }
+
+          alignment.chr = chrNames[refID];
+          alignment.start = pos;
+          alignment.flags = flag;
+          alignment.strand = !(flag & READ_STRAND_FLAG$1);
+          alignment.readName = readName;
+          alignment.cigar = cigar;
+          alignment.lengthOnRef = lengthOnRef;
+          alignment.fragmentLength = tlen;
+          alignment.mq = mq;
+          BamUtils.bam_tag2cigar(ba, blockEnd, p, lseq, alignment, cigarArray);
+          alignment.end = alignment.start + alignment.lengthOnRef;
+
+          if (alignment.end < min) {
+            offset = blockEnd;
+            continue;
+          } // Record out-of-range "to the left", skip to next one
+
+
+          let seq = [];
+          const seqBytes = lseq + 1 >> 1;
+
+          for (let j = 0; j < seqBytes; ++j) {
+            var sb = ba[p + j];
+            seq.push(SEQ_DECODER[(sb & 0xf0) >> 4]);
+            seq.push(SEQ_DECODER[sb & 0x0f]);
+          }
+
+          seq = seq.slice(0, lseq).join(''); // seq might have one extra character (if lseq is an odd number)
+
+          p += seqBytes;
+          const qualArray = [];
+
+          for (let j = 0; j < lseq; ++j) {
+            qualArray.push(ba[p + j]);
+          }
+
+          p += lseq;
+
+          if (mateChrIdx >= 0) {
+            alignment.mate = {
+              chr: chrNames[mateChrIdx],
+              position: matePos,
+              strand: !(flag & MATE_STRAND_FLAG$1)
+            };
+          }
+
+          alignment.seq = seq;
+          alignment.qual = qualArray;
+          alignment.tagBA = new Uint8Array(ba.buffer.slice(p, blockEnd)); // decode these on demand
+
+          this.setPairOrientation(alignment);
+
+          if (undefined === filter || filter.pass(alignment)) {
+            makeBlocks(alignment, cigarArray);
+            alignmentContainer.push(alignment);
+          }
+
+          offset = blockEnd;
+        }
+      },
+      decodeSamRecords: function (sam, alignmentContainer, chr, min, max, filter) {
+        var lines, i, j, len, tokens, qualString, rnext, lengthOnRef, alignment, cigarArray, started;
+        lines = splitLines$3(sam);
+        len = lines.length;
+        started = false;
+
+        for (i = 0; i < len; i++) {
+          tokens = lines[i].split('\t');
+          alignment = new BamAlignment();
+          alignment.chr = tokens[2];
+          alignment.start = Number.parseInt(tokens[3]) - 1;
+          alignment.flags = Number.parseInt(tokens[1]);
+          alignment.readName = tokens[0];
+          alignment.strand = !(alignment.flags & READ_STRAND_FLAG$1);
+          alignment.mq = Number.parseInt(tokens[4]);
+          alignment.cigar = tokens[5];
+          alignment.fragmentLength = Number.parseInt(tokens[8]);
+          alignment.seq = tokens[9];
+          if (alignment.chr === '*' || !alignment.isMapped()) continue; // Unmapped
+
+          if (alignment.chr !== chr) {
+            if (started) break; // Off the right edge, we're done
+            else continue; // Possibly to the left, skip but keep looping
+          } else if (alignment.start > max) {
+            break; // off right edge, we're done
+          }
+
+          lengthOnRef = 0;
+          cigarArray = buildOperators(alignment.cigar);
+          cigarArray.forEach(function (op) {
+            var opLen = op.len;
+            var opLtr = op.ltr;
+            if (opLtr === 'M' || opLtr === 'EQ' || opLtr === 'X' || opLtr === 'D' || opLtr === 'N' || opLtr === '=') lengthOnRef += opLen;
+          });
+          alignment.lengthOnRef = lengthOnRef; // TODO for lh3: parse the CG:B,I tag in SAM here
+
+          if (alignment.start + lengthOnRef < min) {
+            continue; // To the left, skip and continue
+          }
+
+          qualString = tokens[10];
+          alignment.qual = [];
+
+          for (j = 0; j < qualString.length; j++) {
+            alignment.qual[j] = qualString.charCodeAt(j) - 33;
+          }
+
+          alignment.tagDict = tokens.length < 11 ? {} : decodeSamTags(tokens.slice(11));
+
+          if (alignment.isMateMapped()) {
+            rnext = tokens[6];
+            alignment.mate = {
+              chr: rnext === '=' ? alignment.chr : rnext,
+              position: Number.parseInt(tokens[7]),
+              strand: !(alignment.flags & MATE_STRAND_FLAG$1)
+            };
+          }
+
+          this.setPairOrientation(alignment);
+
+          if (undefined === filter || filter.pass(alignment)) {
+            makeBlocks(alignment, cigarArray);
+            alignmentContainer.push(alignment);
+          }
+        }
+      },
+      setReaderDefaults: function (reader, config) {
+        reader.filter = new BamFilter(config.filter);
+
+        if (config.readgroup) {
+          reader.filter.readgroups = new Set([config.readgroup]);
+        }
+
+        reader.alleleFreqThreshold = config.alleleFreqThreshold === undefined ? DEFAULT_ALLELE_FREQ_THRESHOLD : config.alleleFreqThreshold;
+        reader.samplingWindowSize = config.samplingWindowSize === undefined ? DEFAULT_SAMPLING_WINDOW_SIZE : config.samplingWindowSize;
+        reader.samplingDepth = config.samplingDepth === undefined ? DEFAULT_SAMPLING_DEPTH : config.samplingDepth;
+
+        if (reader.samplingDepth > MAXIMUM_SAMPLING_DEPTH) {
+          reader.samplingDepth = MAXIMUM_SAMPLING_DEPTH;
+        }
+
+        if (config.viewAsPairs) {
+          reader.pairsSupported = true;
+        } else {
+          reader.pairsSupported = config.pairsSupported === undefined ? true : config.pairsSupported;
+        }
+      },
+      setPairOrientation: function (alignment) {
+        if (alignment.isMapped() && alignment.mate && alignment.isMateMapped() && alignment.mate.chr === alignment.chr) {
+          var s1 = alignment.strand ? 'F' : 'R';
+          var mate = alignment.mate;
+          var s2 = mate.strand ? 'F' : 'R';
+          var o1 = ' ';
+          var o2 = ' ';
+
+          if (alignment.isFirstOfPair()) {
+            o1 = '1';
+            o2 = '2';
+          } else if (alignment.isSecondOfPair()) {
+            o1 = '2';
+            o2 = '1';
+          }
+
+          var tmp = [];
+          var isize = alignment.fragmentLength;
+          var estReadLen = alignment.end - alignment.start;
+
+          if (isize === 0) {
+            //isize not recorded.  Need to estimate.  This calculation was validated against an Illumina
+            // -> <- library bam.
+            var estMateEnd = alignment.start < mate.position ? mate.position + estReadLen : mate.position - estReadLen;
+            isize = estMateEnd - alignment.start;
+          } //if (isize > estReadLen) {
+
+
+          if (isize > 0) {
+            tmp[0] = s1;
+            tmp[1] = o1;
+            tmp[2] = s2;
+            tmp[3] = o2;
+          } else {
+            tmp[2] = s1;
+            tmp[3] = o1;
+            tmp[0] = s2;
+            tmp[1] = o2;
+          } // }
+
+
+          alignment.pairOrientation = tmp.join('');
+        }
+      }
+    };
+    /**
+     * Split the alignment record into blocks as specified in the cigarArray.  Each aligned block contains
+     * its portion of the read sequence and base quality strings.  A read sequence or base quality string
+     * of "*" indicates the value is not recorded.  In all other cases the length of the block sequence (block.seq)
+     * and quality string (block.qual) must == the block length.
+     *
+     * @param alignment
+     * @param cigarArray
+     * @returns array of blocks
+     */
+
+    function makeBlocks(alignment, cigarArray) {
+      const blocks = [];
+      let insertions;
+      let gaps;
+      let seqOffset = 0;
+      let pos = alignment.start;
+      alignment.scStart = alignment.start;
+      alignment.scLengthOnRef = alignment.lengthOnRef;
+
+      for (let c of cigarArray) {
+        let scPos;
+
+        switch (c.ltr) {
+          case 'H':
+            break;
+          // ignore hard clips
+
+          case 'P':
+            break;
+          // ignore pads
+
+          case 'S':
+            scPos = pos;
+            alignment.scLengthOnRef += c.len;
+
+            if (blocks.length === 0) {
+              alignment.scStart -= c.len;
+              scPos -= c.len;
+            }
+
+            blocks.push(new AlignmentBlock({
+              start: scPos,
+              seqOffset: seqOffset,
+              len: c.len,
+              type: 'S'
+            }));
+            seqOffset += c.len;
+            break;
+          // soft clip read bases
+
+          case 'N':
+          case 'D':
+            if (gaps === undefined) {
+              gaps = [];
+            }
+
+            gaps.push({
+              start: pos,
+              len: c.len,
+              type: c.ltr
+            });
+            pos += c.len;
+            break;
+
+          case 'I':
+            if (insertions === undefined) {
+              insertions = [];
+            }
+
+            insertions.push(new AlignmentBlock({
+              start: pos,
+              len: c.len,
+              seqOffset: seqOffset,
+              type: 'I'
+            }));
+            seqOffset += c.len;
+            break;
+
+          case 'M':
+          case 'EQ':
+          case '=':
+          case 'X':
+            blocks.push(new AlignmentBlock({
+              start: pos,
+              seqOffset: seqOffset,
+              len: c.len,
+              type: 'M'
+            }));
+            seqOffset += c.len;
+            pos += c.len;
+            break;
+        }
+      }
+
+      alignment.blocks = blocks;
+      alignment.insertions = insertions;
+      alignment.gaps = gaps;
+    }
+
+    function readInt(ba, offset) {
+      return ba[offset + 3] << 24 | ba[offset + 2] << 16 | ba[offset + 1] << 8 | ba[offset];
+    }
+    /**
+     * Build a list of cigar operators from a cigarString.  Removes padding operators and concatenates consecutive
+     * operators of the same type
+     *
+     * @param cigarString
+     * @return
+     */
+
+
+    function buildOperators(cigarString) {
+      var operators, buffer, i, len, prevOp, next, op, nBases;
+      operators = [];
+      buffer = []; // Create list of cigar operators
+
+      prevOp = null;
+      len = cigarString.length;
+
+      for (i = 0; i < len; i++) {
+        next = cigarString.charAt(i);
+
+        if (isDigit(next)) {
+          buffer.push(next);
+        } else {
+          op = next;
+          nBases = Number.parseInt(buffer.join(''));
+          buffer = [];
+
+          if (prevOp !== null && prevOp.ltr === op) {
+            prevOp.len += nBases;
+          } else {
+            prevOp = {
+              len: nBases,
+              ltr: op
+            };
+            operators.push(prevOp);
+          }
+        }
+      }
+
+      return operators;
+    }
+
+    function isDigit(a) {
+      var charCode = a.charCodeAt(0);
+      return charCode >= 48 && charCode <= 57; // 0-9
+    }
+
+    function decodeSamTags(tags) {
+      var tagDict = {};
+      tags.forEach(function (tag) {
+        var tokens = tag.split(':');
+        tagDict[tokens[0]] = tokens[2];
+      });
+      return tagDict;
+    }
+
+    const isString$2 = isString$6;
+    /**
+     * Class for reading a bam file
+     *
+     * @param config
+     * @constructor
+     */
+
+    class BamReaderNonIndexed {
+      constructor(config, genome) {
+        this.config = config;
+        this.genome = genome;
+        this.bamPath = config.url;
+        this.isDataUri = isString$2(config.url) && config.url.startsWith("data:");
+        BamUtils.setReaderDefaults(this, config);
+      } // Return an alignment container
+
+
+      async readAlignments(chr, bpStart, bpEnd) {
+        this.genome;
+
+        if (this.alignmentCache) {
+          const header = this.header;
+          const queryChr = header.chrAliasTable.hasOwnProperty(chr) ? header.chrAliasTable[chr] : chr;
+          const qAlignments = this.alignmentCache.queryFeatures(queryChr, bpStart, bpEnd);
+          const alignmentContainer = new AlignmentContainer(chr, bpStart, bpEnd, this.samplingWindowSize, this.samplingDepth, this.pairsSupported, this.alleleFreqThreshold);
+
+          for (let a of qAlignments) {
+            alignmentContainer.push(a);
+          }
+
+          alignmentContainer.finish();
+          return alignmentContainer;
+        } else {
+          if (this.isDataUri) {
+            const data = decodeDataURI(this.bamPath);
+            const unc = unbgzf(data.buffer);
+            this.parseAlignments(this, unc);
+            return this.fetchAlignments(chr, bpStart, bpEnd);
+          } else {
+            const arrayBuffer = await igvxhr.loadArrayBuffer(this.bamPath, buildOptions(this.config));
+            const unc = unbgzf(arrayBuffer);
+            this.parseAlignments(unc);
+            return this.fetchAlignments(chr, bpStart, bpEnd);
+          }
+        }
+      }
+
+    }
+
+    function decodeDataURI(dataURI) {
+      const split = dataURI.split(',');
+      const info = split[0].split(':')[1];
+      let dataString = split[1];
+
+      if (info.indexOf('base64') >= 0) {
+        dataString = atob(dataString);
+      } else {
+        dataString = decodeURI(dataString);
+      }
+
+      const bytes = new Uint8Array(dataString.length);
+
+      for (var i = 0; i < dataString.length; i++) {
+        bytes[i] = dataString.charCodeAt(i);
+      }
+
+      return bytes;
+    }
+
+    /*
+     * The MIT License (MIT)
+     *
+     * Copyright (c) 2016-2017 The Regents of the University of California
+     * Author: Jim Robinson
+     *
+     * Permission is hereby granted, free of charge, to any person obtaining a copy
+     * of this software and associated documentation files (the "Software"), to deal
+     * in the Software without restriction, including without limitation the rights
+     * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+     * copies of the Software, and to permit persons to whom the Software is
+     * furnished to do so, subject to the following conditions:
+     *
+     * The above copyright notice and this permission notice shall be included in
+     * all copies or substantial portions of the Software.
+     *
+     *
+     * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+     * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+     * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+     * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+     * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+     * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+     * THE SOFTWARE.
+     */
+    /**
+     * Class for reading a bam file
+     *
+     * @param config
+     * @constructor
+     */
+
+    class BamReader {
+      constructor(config, genome) {
+        this.config = config;
+        this.genome = genome;
+        this.bamPath = config.url; // Todo - deal with Picard convention.  WHY DOES THERE HAVE TO BE 2?
+
+        this.baiPath = config.indexURL;
+
+        if (!this.baiPath && config.indexed !== false && !(this.bamPath instanceof File)) {
+          this.baiPath = inferIndexPath(this.bamPath, "bai");
+          console.error(`Warning: no indexURL specified for ${this.config.url}.  Guessing ${this.baiPath}`);
+        }
+
+        BamUtils.setReaderDefaults(this, config);
+      }
+
+      async readAlignments(chr, bpStart, bpEnd) {
+        const chrToIndex = await this.getChrIndex();
+        const queryChr = this.chrAliasTable.hasOwnProperty(chr) ? this.chrAliasTable[chr] : chr;
+        const chrId = chrToIndex[queryChr];
+        const alignmentContainer = new AlignmentContainer(chr, bpStart, bpEnd, this.config.samplingWindowSize, this.config.samplingDepth, this.config.pairsSupported, this.config.alleleFreqThreshold);
+
+        if (chrId === undefined) {
+          return alignmentContainer;
+        } else {
+          const bamIndex = await this.getIndex();
+          const chunks = bamIndex.blocksForRange(chrId, bpStart, bpEnd);
+
+          if (!chunks || chunks.length === 0) {
+            return alignmentContainer;
+          }
+
+          for (let c of chunks) {
+            let lastBlockSize;
+
+            if (c.maxv.offset === 0) {
+              lastBlockSize = 0; // Don't need to read the last block.
+            } else {
+              const bsizeOptions = buildOptions(this.config, {
+                range: {
+                  start: c.maxv.block,
+                  size: 26
+                }
+              });
+              const abuffer = await igvxhr.loadArrayBuffer(this.bamPath, bsizeOptions);
+              lastBlockSize = bgzBlockSize(abuffer);
+            }
+
+            const fetchMin = c.minv.block;
+            const fetchMax = c.maxv.block + lastBlockSize;
+            const range = {
+              start: fetchMin,
+              size: fetchMax - fetchMin + 1
+            };
+            const compressed = await igvxhr.loadArrayBuffer(this.bamPath, buildOptions(this.config, {
+              range: range
+            }));
+            var ba = unbgzf(compressed); //new Uint8Array(BGZip.unbgzf(compressed)); //, c.maxv.block - c.minv.block + 1));
+
+            const done = BamUtils.decodeBamRecords(ba, c.minv.offset, alignmentContainer, this.indexToChr, chrId, bpStart, bpEnd, this.filter);
+
+            if (done) {
+              break;
+            }
+          }
+
+          alignmentContainer.finish();
+          return alignmentContainer;
+        }
+      }
+
+      async getHeader() {
+        if (!this.header) {
+          const genome = this.genome;
+          const index = await this.getIndex();
+          let len;
+
+          if (index.firstAlignmentBlock) {
+            const bsizeOptions = buildOptions(this.config, {
+              range: {
+                start: index.firstAlignmentBlock,
+                size: 26
+              }
+            });
+            const abuffer = await igvxhr.loadArrayBuffer(this.bamPath, bsizeOptions);
+            const bsize = bgzBlockSize(abuffer);
+            len = index.firstAlignmentBlock + bsize; // Insure we get the complete compressed block containing the header
+          } else {
+            len = 64000;
+          }
+
+          const options = buildOptions(this.config, {
+            range: {
+              start: 0,
+              size: len
+            }
+          });
+          this.header = await BamUtils.readHeader(this.bamPath, options, genome);
+        }
+
+        return this.header;
+      }
+
+      async getIndex() {
+        const genome = this.genome;
+
+        if (!this.index) {
+          this.index = await loadIndex(this.baiPath, this.config, genome);
+        }
+
+        return this.index;
+      }
+
+      async getChrIndex() {
+        if (this.chrToIndex) {
+          return this.chrToIndex;
+        } else {
+          const header = await this.getHeader();
+          this.chrToIndex = header.chrToIndex;
+          this.indexToChr = header.chrNames;
+          this.chrAliasTable = header.chrAliasTable;
+          return this.chrToIndex;
+        }
+      }
+
+    }
+
+    /*
+     * The MIT License (MIT)
+     *
+     * Copyright (c) 2016-2017 The Regents of the University of California
+     * Author: Jim Robinson
+     *
+     * Permission is hereby granted, free of charge, to any person obtaining a copy
+     * of this software and associated documentation files (the "Software"), to deal
+     * in the Software without restriction, including without limitation the rights
+     * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+     * copies of the Software, and to permit persons to whom the Software is
+     * furnished to do so, subject to the following conditions:
+     *
+     * The above copyright notice and this permission notice shall be included in
+     * all copies or substantial portions of the Software.
+     *
+     *
+     * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+     * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+     * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+     * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+     * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+     * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+     * THE SOFTWARE.
+     */
+
+    class ShardedBamReader {
+      constructor(config, genome) {
+        this.config = config;
+        this.genome = genome;
+        const bamReaders = {};
+        const chrAliasTable = {};
+        config.sources.sequences.forEach(function (chr) {
+          bamReaders[chr] = null; // Placeholder
+
+          if (genome) {
+            const alias = genome.getChromosomeName(chr);
+            chrAliasTable[alias] = chr;
+          }
+        });
+        this.chrAliasTable = chrAliasTable;
+        this.bamReaders = bamReaders;
+        BamUtils.setReaderDefaults(this, config);
+      }
+
+      async readAlignments(chr, start, end) {
+        this.genome;
+        const self = this;
+        const queryChr = self.chrAliasTable.hasOwnProperty(chr) ? self.chrAliasTable[chr] : chr;
+
+        if (!this.bamReaders.hasOwnProperty(queryChr) || "none" === this.bamReaders[queryChr]) {
+          return Promise.resolve(new AlignmentContainer(chr, start, end));
+        } else {
+          let reader = self.bamReaders[queryChr];
+          let tmp;
+
+          if (!reader) {
+            tmp = {
+              url: self.config.sources.url.replace("$CHR", queryChr)
+            };
+
+            if (self.config.sources.indexURL) {
+              tmp.indexURL = self.config.sources.indexURL.replace("$CHR", queryChr);
+            }
+
+            const bamConfig = Object.assign(self.config, tmp);
+            reader = new BamReader(bamConfig);
+            self.bamReaders[queryChr] = reader;
+          }
+
+          return reader.readAlignments(queryChr, start, end).catch(function (error) {
+            console.error(error);
+            const str = `Error reading BAM or index file for: ${tmp ? tmp.url : ''}`;
+            Alert.presentAlert(new Error(str));
+            self.bamReaders[queryChr] = "none";
+            return new AlignmentContainer(chr, start, end); // Empty alignment container
+          });
+        }
+      }
+
+    }
+
+    /*
+     * The MIT License (MIT)
+     *
+     * Copyright (c) 2016-2017 The Regents of the University of California
+     * Author: Jim Robinson
+     *
+     * Permission is hereby granted, free of charge, to any person obtaining a copy
+     * of this software and associated documentation files (the "Software"), to deal
+     * in the Software without restriction, including without limitation the rights
+     * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+     * copies of the Software, and to permit persons to whom the Software is
+     * furnished to do so, subject to the following conditions:
+     *
+     * The above copyright notice and this permission notice shall be included in
+     * all copies or substantial portions of the Software.
+     *
+     *
+     * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+     * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+     * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+     * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+     * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+     * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+     * THE SOFTWARE.
+     */
+    /**
+     * Class for reading bam records from an igv.js-flask server backed by pysam.  Deprecated.
+     *
+     * @param config
+     * @constructor
+     */
+
+    const BamWebserviceReader = function (config, genome) {
+      this.config = config;
+      this.genome = genome;
+      BamUtils.setReaderDefaults(this, config);
+    }; // Example http://localhost:5000/alignments/?reference=/Users/jrobinso/hg19mini.fa&file=/Users/jrobinso/cram_with_crai_index.cram&region=1:100-2000
+
+
+    BamWebserviceReader.prototype.readAlignments = function (chr, bpStart, bpEnd) {
+      var self = this;
+      return getHeader.call(self).then(function (header) {
+        var queryChr, url;
+        queryChr = header.chrAliasTable.hasOwnProperty(chr) ? header.chrAliasTable[chr] : chr;
+        url = self.config.url + "?reference=" + self.config.referenceFile + "&file=" + self.config.alignmentFile + "" + "&region=" + queryChr + ":" + bpStart + "-" + bpEnd;
+        return igvxhr.loadString(url, buildOptions(self.config)).then(function (sam) {
+          var alignmentContainer;
+          header.chrToIndex[queryChr];
+          alignmentContainer = new AlignmentContainer(chr, bpStart, bpEnd, self.samplingWindowSize, self.samplingDepth, self.pairsSupported, self.alleleFreqThreshold);
+          BamUtils.decodeSamRecords(sam, alignmentContainer, queryChr, bpStart, bpEnd, self.filter);
+          return alignmentContainer;
+        });
+      });
+    }; // Example  http://localhost:5000/alignments/?reference=/Users/jrobinso/hg19mini.fa&file=/Users/jrobinso/cram_with_crai_index.cram&options=-b%20-H
+
+
+    function getHeader() {
+      const self = this;
+      const genome = this.genome;
+
+      if (this.header) {
+        return Promise.resolve(this.header);
+      } else {
+        const url = this.config.url + "?file=" + this.config.alignmentFile + "&options=-b,-H";
+        const options = buildOptions(this.config);
+        return BamUtils.readHeader(url, options, genome).then(function (header) {
+          self.header = header;
+          return header;
+        });
+      }
+    }
+
+    /*
+     * The MIT License (MIT)
+     *
+     * Copyright (c) 2016-2017 The Regents of the University of California
+     * Author: Jim Robinson
+     *
+     * Permission is hereby granted, free of charge, to any person obtaining a copy
+     * of this software and associated documentation files (the "Software"), to deal
+     * in the Software without restriction, including without limitation the rights
+     * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+     * copies of the Software, and to permit persons to whom the Software is
+     * furnished to do so, subject to the following conditions:
+     *
+     * The above copyright notice and this permission notice shall be included in
+     * all copies or substantial portions of the Software.
+     *
+     *
+     * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+     * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+     * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+     * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+     * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+     * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+     * THE SOFTWARE.
+     */
+
+    class HtsgetBamReader extends HtsgetReader {
+      constructor(config, genome) {
+        super(config, genome);
+        BamUtils.setReaderDefaults(this, config);
+      }
+
+      async readAlignments(chr, start, end) {
+        if (!this.header) {
+          const compressedData = await this.readHeaderData();
+          const ba = unbgzf(compressedData.buffer);
+          this.header = BamUtils.decodeBamHeader(ba, this.genome);
+          this.chrAliasTable = new Map();
+
+          for (let key of Object.keys(this.header.chrAliasTable)) {
+            this.chrAliasTable.set(key, this.header.chrAliasTable[key]);
+          }
+        }
+
+        let queryChr = this.chrAliasTable.has(chr) ? this.chrAliasTable.get(chr) : chr;
+        const compressedData = await this.readData(queryChr, start, end); // BAM decoding
+
+        const ba = unbgzf(compressedData.buffer);
+        const chrIdx = this.header.chrToIndex[chr];
+        const alignmentContainer = new AlignmentContainer(chr, start, end, this.samplingWindowSize, this.samplingDepth, this.pairsSupported, this.alleleFreqThreshold);
+        BamUtils.decodeBamRecords(ba, this.header.size, alignmentContainer, this.header.chrNames, chrIdx, start, end);
+        alignmentContainer.finish();
+        return alignmentContainer;
+      }
+
+    }
+
+    var $propertyIsEnumerable = {}.propertyIsEnumerable; // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
+
+    var getOwnPropertyDescriptor$1 = Object.getOwnPropertyDescriptor; // Nashorn ~ JDK8 bug
+
+    var NASHORN_BUG = getOwnPropertyDescriptor$1 && !$propertyIsEnumerable.call({
+      1: 2
+    }, 1); // `Object.prototype.propertyIsEnumerable` method implementation
+    // https://tc39.es/ecma262/#sec-object.prototype.propertyisenumerable
+
+    var f$3 = NASHORN_BUG ? function propertyIsEnumerable(V) {
+      var descriptor = getOwnPropertyDescriptor$1(this, V);
+      return !!descriptor && descriptor.enumerable;
+    } : $propertyIsEnumerable;
+    var objectPropertyIsEnumerable = {
+      f: f$3
+    };
+
+    var split = ''.split; // fallback for non-array-like ES3 and non-enumerable old V8 strings
+
+    var indexedObject = fails(function () {
+      // throws an error in rhino, see https://github.com/mozilla/rhino/issues/346
+      // eslint-disable-next-line no-prototype-builtins -- safe
+      return !Object('z').propertyIsEnumerable(0);
+    }) ? function (it) {
+      return classofRaw(it) == 'String' ? split.call(it, '') : Object(it);
+    } : Object;
+
+    var toIndexedObject = function (it) {
+      return indexedObject(requireObjectCoercible(it));
+    };
+
+    var $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor; // `Object.getOwnPropertyDescriptor` method
+    // https://tc39.es/ecma262/#sec-object.getownpropertydescriptor
+
+    var f$2 = descriptors ? $getOwnPropertyDescriptor : function getOwnPropertyDescriptor(O, P) {
+      O = toIndexedObject(O);
+      P = toPrimitive(P, true);
+      if (ie8DomDefine) try {
+        return $getOwnPropertyDescriptor(O, P);
+      } catch (error) {
+        /* empty */
+      }
+      if (has$1(O, P)) return createPropertyDescriptor(!objectPropertyIsEnumerable.f.call(O, P), O[P]);
+    };
+    var objectGetOwnPropertyDescriptor = {
+      f: f$2
+    };
+
+    var max = Math.max;
+    var min = Math.min; // Helper for a popular repeating case of the spec:
+    // Let integer be ? ToInteger(index).
+    // If integer < 0, let result be max((length + integer), 0); else let result be min(integer, length).
+
+    var toAbsoluteIndex = function (index, length) {
+      var integer = toInteger(index);
+      return integer < 0 ? max(integer + length, 0) : min(integer, length);
+    };
+
+    var createMethod = function (IS_INCLUDES) {
+      return function ($this, el, fromIndex) {
+        var O = toIndexedObject($this);
+        var length = toLength(O.length);
+        var index = toAbsoluteIndex(fromIndex, length);
+        var value; // Array#includes uses SameValueZero equality algorithm
+        // eslint-disable-next-line no-self-compare -- NaN check
+
+        if (IS_INCLUDES && el != el) while (length > index) {
+          value = O[index++]; // eslint-disable-next-line no-self-compare -- NaN check
+
+          if (value != value) return true; // Array#indexOf ignores holes, Array#includes - not
+        } else for (; length > index; index++) {
+          if ((IS_INCLUDES || index in O) && O[index] === el) return IS_INCLUDES || index || 0;
+        }
+        return !IS_INCLUDES && -1;
+      };
+    };
+
+    var arrayIncludes = {
+      // `Array.prototype.includes` method
+      // https://tc39.es/ecma262/#sec-array.prototype.includes
+      includes: createMethod(true),
+      // `Array.prototype.indexOf` method
+      // https://tc39.es/ecma262/#sec-array.prototype.indexof
+      indexOf: createMethod(false)
+    };
+
+    var indexOf = arrayIncludes.indexOf;
+
+    var objectKeysInternal = function (object, names) {
+      var O = toIndexedObject(object);
+      var i = 0;
+      var result = [];
+      var key;
+
+      for (key in O) !has$1(hiddenKeys$1, key) && has$1(O, key) && result.push(key); // Don't enum bug & hidden keys
+
+
+      while (names.length > i) if (has$1(O, key = names[i++])) {
+        ~indexOf(result, key) || result.push(key);
+      }
+
+      return result;
+    };
+
+    // IE8- don't enum bug keys
+    var enumBugKeys = ['constructor', 'hasOwnProperty', 'isPrototypeOf', 'propertyIsEnumerable', 'toLocaleString', 'toString', 'valueOf'];
+
+    var hiddenKeys = enumBugKeys.concat('length', 'prototype'); // `Object.getOwnPropertyNames` method
+    // https://tc39.es/ecma262/#sec-object.getownpropertynames
+    // eslint-disable-next-line es/no-object-getownpropertynames -- safe
+
+    var f$1 = Object.getOwnPropertyNames || function getOwnPropertyNames(O) {
+      return objectKeysInternal(O, hiddenKeys);
+    };
+
+    var objectGetOwnPropertyNames = {
+      f: f$1
+    };
+
+    // eslint-disable-next-line es/no-object-getownpropertysymbols -- safe
+    var f = Object.getOwnPropertySymbols;
+    var objectGetOwnPropertySymbols = {
+      f: f
+    };
+
+    var ownKeys = getBuiltIn('Reflect', 'ownKeys') || function ownKeys(it) {
+      var keys = objectGetOwnPropertyNames.f(anObject(it));
+      var getOwnPropertySymbols = objectGetOwnPropertySymbols.f;
+      return getOwnPropertySymbols ? keys.concat(getOwnPropertySymbols(it)) : keys;
+    };
+
+    var copyConstructorProperties = function (target, source) {
+      var keys = ownKeys(source);
+      var defineProperty = objectDefineProperty.f;
+      var getOwnPropertyDescriptor = objectGetOwnPropertyDescriptor.f;
+
+      for (var i = 0; i < keys.length; i++) {
+        var key = keys[i];
+        if (!has$1(target, key)) defineProperty(target, key, getOwnPropertyDescriptor(source, key));
+      }
+    };
+
+    var replacement = /#|\.prototype\./;
+
+    var isForced = function (feature, detection) {
+      var value = data[normalize(feature)];
+      return value == POLYFILL ? true : value == NATIVE ? false : typeof detection == 'function' ? fails(detection) : !!detection;
+    };
+
+    var normalize = isForced.normalize = function (string) {
+      return String(string).replace(replacement, '.').toLowerCase();
+    };
+
+    var data = isForced.data = {};
+    var NATIVE = isForced.NATIVE = 'N';
+    var POLYFILL = isForced.POLYFILL = 'P';
+    var isForced_1 = isForced;
+
+    var getOwnPropertyDescriptor = objectGetOwnPropertyDescriptor.f;
+    /*
+      options.target      - name of the target object
+      options.global      - target is the global object
+      options.stat        - export as static methods of target
+      options.proto       - export as prototype methods of target
+      options.real        - real prototype method for the `pure` version
+      options.forced      - export even if the native feature is available
+      options.bind        - bind methods to the target, required for the `pure` version
+      options.wrap        - wrap constructors to preventing global pollution, required for the `pure` version
+      options.unsafe      - use the simple assignment of property instead of delete + defineProperty
+      options.sham        - add a flag to not completely full polyfills
+      options.enumerable  - export as enumerable property
+      options.noTargetGet - prevent calling a getter on target
+    */
+
+    var _export = function (options, source) {
+      var TARGET = options.target;
+      var GLOBAL = options.global;
+      var STATIC = options.stat;
+      var FORCED, target, key, targetProperty, sourceProperty, descriptor;
+
+      if (GLOBAL) {
+        target = global$1;
+      } else if (STATIC) {
+        target = global$1[TARGET] || setGlobal(TARGET, {});
+      } else {
+        target = (global$1[TARGET] || {}).prototype;
+      }
+
+      if (target) for (key in source) {
+        sourceProperty = source[key];
+
+        if (options.noTargetGet) {
+          descriptor = getOwnPropertyDescriptor(target, key);
+          targetProperty = descriptor && descriptor.value;
+        } else targetProperty = target[key];
+
+        FORCED = isForced_1(GLOBAL ? key : TARGET + (STATIC ? '.' : '#') + key, options.forced); // contained in target
+
+        if (!FORCED && targetProperty !== undefined) {
+          if (typeof sourceProperty === typeof targetProperty) continue;
+          copyConstructorProperties(sourceProperty, targetProperty);
+        } // add a flag to not completely full polyfills
+
+
+        if (options.sham || targetProperty && targetProperty.sham) {
+          createNonEnumerableProperty(sourceProperty, 'sham', true);
+        } // extend global
+
+
+        redefine(target, key, sourceProperty, options);
+      }
+    };
+
+    var functionBindContext = function (fn, that, length) {
+      aFunction(fn);
+      if (that === undefined) return fn;
+
+      switch (length) {
+        case 0:
+          return function () {
+            return fn.call(that);
+          };
+
+        case 1:
+          return function (a) {
+            return fn.call(that, a);
+          };
+
+        case 2:
+          return function (a, b) {
+            return fn.call(that, a, b);
+          };
+
+        case 3:
+          return function (a, b, c) {
+            return fn.call(that, a, b, c);
+          };
+      }
+
+      return function () {
+        return fn.apply(that, arguments);
+      };
+    };
+
+    var html = getBuiltIn('document', 'documentElement');
+
+    var engineIsIos = /(?:iphone|ipod|ipad).*applewebkit/i.test(engineUserAgent);
+
+    var engineIsNode = classofRaw(global$1.process) == 'process';
+
+    var location = global$1.location;
+    var set = global$1.setImmediate;
+    var clear = global$1.clearImmediate;
+    var process$1 = global$1.process;
+    var MessageChannel$1 = global$1.MessageChannel;
+    var Dispatch = global$1.Dispatch;
+    var counter = 0;
+    var queue = {};
+    var ONREADYSTATECHANGE = 'onreadystatechange';
+    var defer, channel, port;
+
+    var run = function (id) {
+      // eslint-disable-next-line no-prototype-builtins -- safe
+      if (queue.hasOwnProperty(id)) {
+        var fn = queue[id];
+        delete queue[id];
+        fn();
+      }
+    };
+
+    var runner = function (id) {
+      return function () {
+        run(id);
+      };
+    };
+
+    var listener = function (event) {
+      run(event.data);
+    };
+
+    var post = function (id) {
+      // old engines have not location.origin
+      global$1.postMessage(id + '', location.protocol + '//' + location.host);
+    }; // Node.js 0.9+ & IE10+ has setImmediate, otherwise:
+
+
+    if (!set || !clear) {
+      set = function setImmediate(fn) {
+        var args = [];
+        var i = 1;
+
+        while (arguments.length > i) args.push(arguments[i++]);
+
+        queue[++counter] = function () {
+          // eslint-disable-next-line no-new-func -- spec requirement
+          (typeof fn == 'function' ? fn : Function(fn)).apply(undefined, args);
+        };
+
+        defer(counter);
+        return counter;
+      };
+
+      clear = function clearImmediate(id) {
+        delete queue[id];
+      }; // Node.js 0.8-
+
+
+      if (engineIsNode) {
+        defer = function (id) {
+          process$1.nextTick(runner(id));
+        }; // Sphere (JS game engine) Dispatch API
+
+      } else if (Dispatch && Dispatch.now) {
+        defer = function (id) {
+          Dispatch.now(runner(id));
+        }; // Browsers with MessageChannel, includes WebWorkers
+        // except iOS - https://github.com/zloirock/core-js/issues/624
+
+      } else if (MessageChannel$1 && !engineIsIos) {
+        channel = new MessageChannel$1();
+        port = channel.port2;
+        channel.port1.onmessage = listener;
+        defer = functionBindContext(port.postMessage, port, 1); // Browsers with postMessage, skip WebWorkers
+        // IE8 has postMessage, but it's sync & typeof its postMessage is 'object'
+      } else if (global$1.addEventListener && typeof postMessage == 'function' && !global$1.importScripts && location && location.protocol !== 'file:' && !fails(post)) {
+        defer = post;
+        global$1.addEventListener('message', listener, false); // IE8-
+      } else if (ONREADYSTATECHANGE in documentCreateElement('script')) {
+        defer = function (id) {
+          html.appendChild(documentCreateElement('script'))[ONREADYSTATECHANGE] = function () {
+            html.removeChild(this);
+            run(id);
+          };
+        }; // Rest old browsers
+
+      } else {
+        defer = function (id) {
+          setTimeout(runner(id), 0);
+        };
+      }
+    }
+
+    var task = {
+      set: set,
+      clear: clear
+    };
+
+    var FORCED = !global$1.setImmediate || !global$1.clearImmediate; // http://w3c.github.io/setImmediate/
+
+    _export({
+      global: true,
+      bind: true,
+      enumerable: true,
+      forced: FORCED
+    }, {
+      // `setImmediate` method
+      // http://w3c.github.io/setImmediate/#si-setImmediate
+      setImmediate: task.set,
+      // `clearImmediate` method
+      // http://w3c.github.io/setImmediate/#si-clearImmediate
+      clearImmediate: task.clear
+    });
+
+    const eval2 = eval;
+
+    const gmodCRAM = function (t) {
+      var e = {};
+
+      function r(n) {
+        if (e[n]) return e[n].exports;
+        var i = e[n] = {
+          i: n,
+          l: !1,
+          exports: {}
+        };
+        return t[n].call(i.exports, i, i.exports, r), i.l = !0, i.exports;
+      }
+
+      return r.m = t, r.c = e, r.d = function (t, e, n) {
+        r.o(t, e) || Object.defineProperty(t, e, {
+          enumerable: !0,
+          get: n
+        });
+      }, r.r = function (t) {
+        "undefined" != typeof Symbol && Symbol.toStringTag && Object.defineProperty(t, Symbol.toStringTag, {
+          value: "Module"
+        }), Object.defineProperty(t, "__esModule", {
+          value: !0
+        });
+      }, r.t = function (t, e) {
+        if (1 & e && (t = r(t)), 8 & e) return t;
+        if (4 & e && "object" == typeof t && t && t.__esModule) return t;
+        var n = Object.create(null);
+        if (r.r(n), Object.defineProperty(n, "default", {
+          enumerable: !0,
+          value: t
+        }), 2 & e && "string" != typeof t) for (var i in t) r.d(n, i, function (e) {
+          return t[e];
+        }.bind(null, i));
+        return n;
+      }, r.n = function (t) {
+        var e = t && t.__esModule ? function () {
+          return t.default;
+        } : function () {
+          return t;
+        };
+        return r.d(e, "a", e), e;
+      }, r.o = function (t, e) {
+        return Object.prototype.hasOwnProperty.call(t, e);
+      }, r.p = "", r(r.s = 163);
+    }([function (t, e, r) {
+
+      var n = r(13),
+          i = r(81).f,
+          o = r(107),
+          a = r(3),
+          s = r(15),
+          u = r(20),
+          f = r(24),
+          c = function (t) {
+        var e = function (e, r, n) {
+          if (this instanceof t) {
+            switch (arguments.length) {
+              case 0:
+                return new t();
+
+              case 1:
+                return new t(e);
+
+              case 2:
+                return new t(e, r);
+            }
+
+            return new t(e, r, n);
+          }
+
+          return t.apply(this, arguments);
+        };
+
+        return e.prototype = t.prototype, e;
+      };
+
+      t.exports = function (t, e) {
+        var r,
+            l,
+            h,
+            d,
+            p,
+            g,
+            v,
+            y,
+            m = t.target,
+            b = t.global,
+            _ = t.stat,
+            w = t.proto,
+            x = b ? n : _ ? n[m] : (n[m] || {}).prototype,
+            E = b ? a : a[m] || (a[m] = {}),
+            S = E.prototype;
+
+        for (h in e) r = !o(b ? h : m + (_ ? "." : "#") + h, t.forced) && x && f(x, h), p = E[h], r && (g = t.noTargetGet ? (y = i(x, h)) && y.value : x[h]), d = r && g ? g : e[h], r && typeof p == typeof d || (v = t.bind && r ? s(d, n) : t.wrap && r ? c(d) : w && "function" == typeof d ? s(Function.call, d) : d, (t.sham || d && d.sham || p && p.sham) && u(v, "sham", !0), E[h] = v, w && (f(a, l = m + "Prototype") || u(a, l, {}), a[l][h] = d, t.real && S && !S[h] && u(S, h, d)));
+      };
+    }, function (t, e) {
+      t.exports = function (t) {
+        return t && t.__esModule ? t : {
+          default: t
+        };
+      };
+    }, function (t, e, r) {
+      var n = r(14);
+
+      t.exports = function (t) {
+        if (!n(t)) throw TypeError(String(t) + " is not an object");
+        return t;
+      };
+    }, function (t, e) {
+      t.exports = {};
+    }, function (t, e) {
+      t.exports = !0;
+    }, function (t, e) {
+      t.exports = function (t) {
+        if ("function" != typeof t) throw TypeError(String(t) + " is not a function");
+        return t;
+      };
+    }, function (t, e, r) {
+      var n = r(13),
+          i = r(61),
+          o = r(64),
+          a = r(110),
+          s = n.Symbol,
+          u = i("wks");
+
+      t.exports = function (t) {
+        return u[t] || (u[t] = a && s[t] || (a ? s : o)("Symbol." + t));
+      };
+    }, function (t, e) {
+      t.exports = function (t, e) {
+        if (!(t instanceof e)) throw new TypeError("Cannot call a class as a function");
+      };
+    }, function (t, e, r) {
+      var n = r(2),
+          i = r(119),
+          o = r(29),
+          a = r(15),
+          s = r(90),
+          u = r(120),
+          f = function (t, e) {
+        this.stopped = t, this.result = e;
+      };
+
+      (t.exports = function (t, e, r, c, l) {
+        var h,
+            d,
+            p,
+            g,
+            v,
+            y,
+            m = a(e, r, c ? 2 : 1);
+        if (l) h = t;else {
+          if ("function" != typeof (d = s(t))) throw TypeError("Target is not iterable");
+
+          if (i(d)) {
+            for (p = 0, g = o(t.length); g > p; p++) if ((v = c ? m(n(y = t[p])[0], y[1]) : m(t[p])) && v instanceof f) return v;
+
+            return new f(!1);
+          }
+
+          h = d.call(t);
+        }
+
+        for (; !(y = h.next()).done;) if ((v = u(h, m, y.value, c)) && v instanceof f) return v;
+
+        return new f(!1);
+      }).stop = function (t) {
+        return new f(!0, t);
+      };
+    }, function (t, e, r) {
+
+      var n = r(1),
+          i = n(r(7)),
+          o = n(r(32)),
+          a = n(r(27)),
+          s = n(r(33)),
+          u = n(r(265)),
+          f = function (t) {
+        function e() {
+          return (0, i.default)(this, e), (0, o.default)(this, (0, a.default)(e).apply(this, arguments));
+        }
+
+        return (0, s.default)(e, t), e;
+      }((0, u.default)(Error)),
+          c = function (t) {
+        function e() {
+          return (0, i.default)(this, e), (0, o.default)(this, (0, a.default)(e).apply(this, arguments));
+        }
+
+        return (0, s.default)(e, t), e;
+      }((0, u.default)(Error)),
+          l = function (t) {
+        function e() {
+          return (0, i.default)(this, e), (0, o.default)(this, (0, a.default)(e).apply(this, arguments));
+        }
+
+        return (0, s.default)(e, t), e;
+      }(f),
+          h = function (t) {
+        function e() {
+          return (0, i.default)(this, e), (0, o.default)(this, (0, a.default)(e).apply(this, arguments));
+        }
+
+        return (0, s.default)(e, t), e;
+      }(l),
+          d = function (t) {
+        function e() {
+          return (0, i.default)(this, e), (0, o.default)(this, (0, a.default)(e).apply(this, arguments));
+        }
+
+        return (0, s.default)(e, t), e;
+      }(f),
+          p = function (t) {
+        function e() {
+          return (0, i.default)(this, e), (0, o.default)(this, (0, a.default)(e).apply(this, arguments));
+        }
+
+        return (0, s.default)(e, t), e;
+      }(f);
+
+      t.exports = {
+        CramBufferOverrunError: h,
+        CramMalformedError: l,
+        CramUnimplementedError: c,
+        CramSizeLimitError: d,
+        CramArgumentError: p
+      };
+    }, function (t, e, r) {
+      var n = r(196);
+
+      function i(t, e) {
+        for (var r = 0; r < e.length; r++) {
+          var i = e[r];
+          i.enumerable = i.enumerable || !1, i.configurable = !0, "value" in i && (i.writable = !0), n(t, i.key, i);
+        }
+      }
+
+      t.exports = function (t, e, r) {
+        return e && i(t.prototype, e), r && i(t, r), t;
+      };
+    }, function (t, e, r) {
+      var n = r(3),
+          i = r(24),
+          o = r(95),
+          a = r(21).f;
+
+      t.exports = function (t) {
+        var e = n.Symbol || (n.Symbol = {});
+        i(e, t) || a(e, t, {
+          value: o.f(t)
+        });
+      };
+    }, function (t, e) {
+      t.exports = function (t) {
+        try {
+          return !!t();
+        } catch (t) {
+          return !0;
+        }
+      };
+    }, function (t, e, r) {
+      (function (e) {
+        var r = "object",
+            n = function (t) {
+          return t && t.Math == Math && t;
+        };
+
+        t.exports = n(typeof globalThis == r && globalThis) || n(typeof window == r && window) || n(typeof self == r && self) || n(typeof e == r && e) || Function("return this")();
+      }).call(this, r(23));
+    }, function (t, e) {
+      t.exports = function (t) {
+        return "object" == typeof t ? null !== t : "function" == typeof t;
+      };
+    }, function (t, e, r) {
+      var n = r(5);
+
+      t.exports = function (t, e, r) {
+        if (n(t), void 0 === e) return t;
+
+        switch (r) {
+          case 0:
+            return function () {
+              return t.call(e);
+            };
+
+          case 1:
+            return function (r) {
+              return t.call(e, r);
+            };
+
+          case 2:
+            return function (r, n) {
+              return t.call(e, r, n);
+            };
+
+          case 3:
+            return function (r, n, i) {
+              return t.call(e, r, n, i);
+            };
+        }
+
+        return function () {
+          return t.apply(e, arguments);
+        };
+      };
+    }, function (t, e, r) {
+      t.exports = r(167);
+    }, function (t, e, r) {
+      var n = r(12);
+      t.exports = !n(function () {
+        return 7 != Object.defineProperty({}, "a", {
+          get: function () {
+            return 7;
+          }
+        }).a;
+      });
+    }, function (t, e, r) {
+      var n = r(3);
+
+      t.exports = function (t) {
+        return n[t + "Prototype"];
+      };
+    }, function (t, e, r) {
+
+      (function (t) {
+        /*!
+         * The buffer module from node.js, for the browser.
+         *
+         * @author   Feross Aboukhadijeh <feross@feross.org> <http://feross.org>
+         * @license  MIT
+         */
+        var n = r(165),
+            i = r(166),
+            o = r(105);
+
+        function a() {
+          return u.TYPED_ARRAY_SUPPORT ? 2147483647 : 1073741823;
+        }
+
+        function s(t, e) {
+          if (a() < e) throw new RangeError("Invalid typed array length");
+          return u.TYPED_ARRAY_SUPPORT ? (t = new Uint8Array(e)).__proto__ = u.prototype : (null === t && (t = new u(e)), t.length = e), t;
+        }
+
+        function u(t, e, r) {
+          if (!(u.TYPED_ARRAY_SUPPORT || this instanceof u)) return new u(t, e, r);
+
+          if ("number" == typeof t) {
+            if ("string" == typeof e) throw new Error("If encoding is specified then the first argument must be a string");
+            return l(this, t);
+          }
+
+          return f(this, t, e, r);
+        }
+
+        function f(t, e, r, n) {
+          if ("number" == typeof e) throw new TypeError('"value" argument must not be a number');
+          return "undefined" != typeof ArrayBuffer && e instanceof ArrayBuffer ? function (t, e, r, n) {
+            if (e.byteLength, r < 0 || e.byteLength < r) throw new RangeError("'offset' is out of bounds");
+            if (e.byteLength < r + (n || 0)) throw new RangeError("'length' is out of bounds");
+            e = void 0 === r && void 0 === n ? new Uint8Array(e) : void 0 === n ? new Uint8Array(e, r) : new Uint8Array(e, r, n);
+            u.TYPED_ARRAY_SUPPORT ? (t = e).__proto__ = u.prototype : t = h(t, e);
+            return t;
+          }(t, e, r, n) : "string" == typeof e ? function (t, e, r) {
+            "string" == typeof r && "" !== r || (r = "utf8");
+            if (!u.isEncoding(r)) throw new TypeError('"encoding" must be a valid string encoding');
+            var n = 0 | p(e, r),
+                i = (t = s(t, n)).write(e, r);
+            i !== n && (t = t.slice(0, i));
+            return t;
+          }(t, e, r) : function (t, e) {
+            if (u.isBuffer(e)) {
+              var r = 0 | d(e.length);
+              return 0 === (t = s(t, r)).length ? t : (e.copy(t, 0, 0, r), t);
+            }
+
+            if (e) {
+              if ("undefined" != typeof ArrayBuffer && e.buffer instanceof ArrayBuffer || "length" in e) return "number" != typeof e.length || (n = e.length) != n ? s(t, 0) : h(t, e);
+              if ("Buffer" === e.type && o(e.data)) return h(t, e.data);
+            }
+
+            var n;
+            throw new TypeError("First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.");
+          }(t, e);
+        }
+
+        function c(t) {
+          if ("number" != typeof t) throw new TypeError('"size" argument must be a number');
+          if (t < 0) throw new RangeError('"size" argument must not be negative');
+        }
+
+        function l(t, e) {
+          if (c(e), t = s(t, e < 0 ? 0 : 0 | d(e)), !u.TYPED_ARRAY_SUPPORT) for (var r = 0; r < e; ++r) t[r] = 0;
+          return t;
+        }
+
+        function h(t, e) {
+          var r = e.length < 0 ? 0 : 0 | d(e.length);
+          t = s(t, r);
+
+          for (var n = 0; n < r; n += 1) t[n] = 255 & e[n];
+
+          return t;
+        }
+
+        function d(t) {
+          if (t >= a()) throw new RangeError("Attempt to allocate Buffer larger than maximum size: 0x" + a().toString(16) + " bytes");
+          return 0 | t;
+        }
+
+        function p(t, e) {
+          if (u.isBuffer(t)) return t.length;
+          if ("undefined" != typeof ArrayBuffer && "function" == typeof ArrayBuffer.isView && (ArrayBuffer.isView(t) || t instanceof ArrayBuffer)) return t.byteLength;
+          "string" != typeof t && (t = "" + t);
+          var r = t.length;
+          if (0 === r) return 0;
+
+          for (var n = !1;;) switch (e) {
+            case "ascii":
+            case "latin1":
+            case "binary":
+              return r;
+
+            case "utf8":
+            case "utf-8":
+            case void 0:
+              return D(t).length;
+
+            case "ucs2":
+            case "ucs-2":
+            case "utf16le":
+            case "utf-16le":
+              return 2 * r;
+
+            case "hex":
+              return r >>> 1;
+
+            case "base64":
+              return q(t).length;
+
+            default:
+              if (n) return D(t).length;
+              e = ("" + e).toLowerCase(), n = !0;
+          }
+        }
+
+        function g(t, e, r) {
+          var n = !1;
+          if ((void 0 === e || e < 0) && (e = 0), e > this.length) return "";
+          if ((void 0 === r || r > this.length) && (r = this.length), r <= 0) return "";
+          if ((r >>>= 0) <= (e >>>= 0)) return "";
+
+          for (t || (t = "utf8");;) switch (t) {
+            case "hex":
+              return O(this, e, r);
+
+            case "utf8":
+            case "utf-8":
+              return A(this, e, r);
+
+            case "ascii":
+              return T(this, e, r);
+
+            case "latin1":
+            case "binary":
+              return R(this, e, r);
+
+            case "base64":
+              return k(this, e, r);
+
+            case "ucs2":
+            case "ucs-2":
+            case "utf16le":
+            case "utf-16le":
+              return I(this, e, r);
+
+            default:
+              if (n) throw new TypeError("Unknown encoding: " + t);
+              t = (t + "").toLowerCase(), n = !0;
+          }
+        }
+
+        function v(t, e, r) {
+          var n = t[e];
+          t[e] = t[r], t[r] = n;
+        }
+
+        function y(t, e, r, n, i) {
+          if (0 === t.length) return -1;
+
+          if ("string" == typeof r ? (n = r, r = 0) : r > 2147483647 ? r = 2147483647 : r < -2147483648 && (r = -2147483648), r = +r, isNaN(r) && (r = i ? 0 : t.length - 1), r < 0 && (r = t.length + r), r >= t.length) {
+            if (i) return -1;
+            r = t.length - 1;
+          } else if (r < 0) {
+            if (!i) return -1;
+            r = 0;
+          }
+
+          if ("string" == typeof e && (e = u.from(e, n)), u.isBuffer(e)) return 0 === e.length ? -1 : m(t, e, r, n, i);
+          if ("number" == typeof e) return e &= 255, u.TYPED_ARRAY_SUPPORT && "function" == typeof Uint8Array.prototype.indexOf ? i ? Uint8Array.prototype.indexOf.call(t, e, r) : Uint8Array.prototype.lastIndexOf.call(t, e, r) : m(t, [e], r, n, i);
+          throw new TypeError("val must be string, number or Buffer");
+        }
+
+        function m(t, e, r, n, i) {
+          var o,
+              a = 1,
+              s = t.length,
+              u = e.length;
+
+          if (void 0 !== n && ("ucs2" === (n = String(n).toLowerCase()) || "ucs-2" === n || "utf16le" === n || "utf-16le" === n)) {
+            if (t.length < 2 || e.length < 2) return -1;
+            a = 2, s /= 2, u /= 2, r /= 2;
+          }
+
+          function f(t, e) {
+            return 1 === a ? t[e] : t.readUInt16BE(e * a);
+          }
+
+          if (i) {
+            var c = -1;
+
+            for (o = r; o < s; o++) if (f(t, o) === f(e, -1 === c ? 0 : o - c)) {
+              if (-1 === c && (c = o), o - c + 1 === u) return c * a;
+            } else -1 !== c && (o -= o - c), c = -1;
+          } else for (r + u > s && (r = s - u), o = r; o >= 0; o--) {
+            for (var l = !0, h = 0; h < u; h++) if (f(t, o + h) !== f(e, h)) {
+              l = !1;
+              break;
+            }
+
+            if (l) return o;
+          }
+
+          return -1;
+        }
+
+        function b(t, e, r, n) {
+          r = Number(r) || 0;
+          var i = t.length - r;
+          n ? (n = Number(n)) > i && (n = i) : n = i;
+          var o = e.length;
+          if (o % 2 != 0) throw new TypeError("Invalid hex string");
+          n > o / 2 && (n = o / 2);
+
+          for (var a = 0; a < n; ++a) {
+            var s = parseInt(e.substr(2 * a, 2), 16);
+            if (isNaN(s)) return a;
+            t[r + a] = s;
+          }
+
+          return a;
+        }
+
+        function _(t, e, r, n) {
+          return Z(D(e, t.length - r), t, r, n);
+        }
+
+        function w(t, e, r, n) {
+          return Z(function (t) {
+            for (var e = [], r = 0; r < t.length; ++r) e.push(255 & t.charCodeAt(r));
+
+            return e;
+          }(e), t, r, n);
+        }
+
+        function x(t, e, r, n) {
+          return w(t, e, r, n);
+        }
+
+        function E(t, e, r, n) {
+          return Z(q(e), t, r, n);
+        }
+
+        function S(t, e, r, n) {
+          return Z(function (t, e) {
+            for (var r, n, i, o = [], a = 0; a < t.length && !((e -= 2) < 0); ++a) r = t.charCodeAt(a), n = r >> 8, i = r % 256, o.push(i), o.push(n);
+
+            return o;
+          }(e, t.length - r), t, r, n);
+        }
+
+        function k(t, e, r) {
+          return 0 === e && r === t.length ? n.fromByteArray(t) : n.fromByteArray(t.slice(e, r));
+        }
+
+        function A(t, e, r) {
+          r = Math.min(t.length, r);
+
+          for (var n = [], i = e; i < r;) {
+            var o,
+                a,
+                s,
+                u,
+                f = t[i],
+                c = null,
+                l = f > 239 ? 4 : f > 223 ? 3 : f > 191 ? 2 : 1;
+            if (i + l <= r) switch (l) {
+              case 1:
+                f < 128 && (c = f);
+                break;
+
+              case 2:
+                128 == (192 & (o = t[i + 1])) && (u = (31 & f) << 6 | 63 & o) > 127 && (c = u);
+                break;
+
+              case 3:
+                o = t[i + 1], a = t[i + 2], 128 == (192 & o) && 128 == (192 & a) && (u = (15 & f) << 12 | (63 & o) << 6 | 63 & a) > 2047 && (u < 55296 || u > 57343) && (c = u);
+                break;
+
+              case 4:
+                o = t[i + 1], a = t[i + 2], s = t[i + 3], 128 == (192 & o) && 128 == (192 & a) && 128 == (192 & s) && (u = (15 & f) << 18 | (63 & o) << 12 | (63 & a) << 6 | 63 & s) > 65535 && u < 1114112 && (c = u);
+            }
+            null === c ? (c = 65533, l = 1) : c > 65535 && (c -= 65536, n.push(c >>> 10 & 1023 | 55296), c = 56320 | 1023 & c), n.push(c), i += l;
+          }
+
+          return function (t) {
+            var e = t.length;
+            if (e <= C) return String.fromCharCode.apply(String, t);
+            var r = "",
+                n = 0;
+
+            for (; n < e;) r += String.fromCharCode.apply(String, t.slice(n, n += C));
+
+            return r;
+          }(n);
+        }
+
+        e.Buffer = u, e.SlowBuffer = function (t) {
+          +t != t && (t = 0);
+          return u.alloc(+t);
+        }, e.INSPECT_MAX_BYTES = 50, u.TYPED_ARRAY_SUPPORT = void 0 !== t.TYPED_ARRAY_SUPPORT ? t.TYPED_ARRAY_SUPPORT : function () {
+          try {
+            var t = new Uint8Array(1);
+            return t.__proto__ = {
+              __proto__: Uint8Array.prototype,
+              foo: function () {
+                return 42;
+              }
+            }, 42 === t.foo() && "function" == typeof t.subarray && 0 === t.subarray(1, 1).byteLength;
+          } catch (t) {
+            return !1;
+          }
+        }(), e.kMaxLength = a(), u.poolSize = 8192, u._augment = function (t) {
+          return t.__proto__ = u.prototype, t;
+        }, u.from = function (t, e, r) {
+          return f(null, t, e, r);
+        }, u.TYPED_ARRAY_SUPPORT && (u.prototype.__proto__ = Uint8Array.prototype, u.__proto__ = Uint8Array, "undefined" != typeof Symbol && Symbol.species && u[Symbol.species] === u && Object.defineProperty(u, Symbol.species, {
+          value: null,
+          configurable: !0
+        })), u.alloc = function (t, e, r) {
+          return function (t, e, r, n) {
+            return c(e), e <= 0 ? s(t, e) : void 0 !== r ? "string" == typeof n ? s(t, e).fill(r, n) : s(t, e).fill(r) : s(t, e);
+          }(null, t, e, r);
+        }, u.allocUnsafe = function (t) {
+          return l(null, t);
+        }, u.allocUnsafeSlow = function (t) {
+          return l(null, t);
+        }, u.isBuffer = function (t) {
+          return !(null == t || !t._isBuffer);
+        }, u.compare = function (t, e) {
+          if (!u.isBuffer(t) || !u.isBuffer(e)) throw new TypeError("Arguments must be Buffers");
+          if (t === e) return 0;
+
+          for (var r = t.length, n = e.length, i = 0, o = Math.min(r, n); i < o; ++i) if (t[i] !== e[i]) {
+            r = t[i], n = e[i];
+            break;
+          }
+
+          return r < n ? -1 : n < r ? 1 : 0;
+        }, u.isEncoding = function (t) {
+          switch (String(t).toLowerCase()) {
+            case "hex":
+            case "utf8":
+            case "utf-8":
+            case "ascii":
+            case "latin1":
+            case "binary":
+            case "base64":
+            case "ucs2":
+            case "ucs-2":
+            case "utf16le":
+            case "utf-16le":
+              return !0;
+
+            default:
+              return !1;
+          }
+        }, u.concat = function (t, e) {
+          if (!o(t)) throw new TypeError('"list" argument must be an Array of Buffers');
+          if (0 === t.length) return u.alloc(0);
+          var r;
+          if (void 0 === e) for (e = 0, r = 0; r < t.length; ++r) e += t[r].length;
+          var n = u.allocUnsafe(e),
+              i = 0;
+
+          for (r = 0; r < t.length; ++r) {
+            var a = t[r];
+            if (!u.isBuffer(a)) throw new TypeError('"list" argument must be an Array of Buffers');
+            a.copy(n, i), i += a.length;
+          }
+
+          return n;
+        }, u.byteLength = p, u.prototype._isBuffer = !0, u.prototype.swap16 = function () {
+          var t = this.length;
+          if (t % 2 != 0) throw new RangeError("Buffer size must be a multiple of 16-bits");
+
+          for (var e = 0; e < t; e += 2) v(this, e, e + 1);
+
+          return this;
+        }, u.prototype.swap32 = function () {
+          var t = this.length;
+          if (t % 4 != 0) throw new RangeError("Buffer size must be a multiple of 32-bits");
+
+          for (var e = 0; e < t; e += 4) v(this, e, e + 3), v(this, e + 1, e + 2);
+
+          return this;
+        }, u.prototype.swap64 = function () {
+          var t = this.length;
+          if (t % 8 != 0) throw new RangeError("Buffer size must be a multiple of 64-bits");
+
+          for (var e = 0; e < t; e += 8) v(this, e, e + 7), v(this, e + 1, e + 6), v(this, e + 2, e + 5), v(this, e + 3, e + 4);
+
+          return this;
+        }, u.prototype.toString = function () {
+          var t = 0 | this.length;
+          return 0 === t ? "" : 0 === arguments.length ? A(this, 0, t) : g.apply(this, arguments);
+        }, u.prototype.equals = function (t) {
+          if (!u.isBuffer(t)) throw new TypeError("Argument must be a Buffer");
+          return this === t || 0 === u.compare(this, t);
+        }, u.prototype.inspect = function () {
+          var t = "",
+              r = e.INSPECT_MAX_BYTES;
+          return this.length > 0 && (t = this.toString("hex", 0, r).match(/.{2}/g).join(" "), this.length > r && (t += " ... ")), "<Buffer " + t + ">";
+        }, u.prototype.compare = function (t, e, r, n, i) {
+          if (!u.isBuffer(t)) throw new TypeError("Argument must be a Buffer");
+          if (void 0 === e && (e = 0), void 0 === r && (r = t ? t.length : 0), void 0 === n && (n = 0), void 0 === i && (i = this.length), e < 0 || r > t.length || n < 0 || i > this.length) throw new RangeError("out of range index");
+          if (n >= i && e >= r) return 0;
+          if (n >= i) return -1;
+          if (e >= r) return 1;
+          if (this === t) return 0;
+
+          for (var o = (i >>>= 0) - (n >>>= 0), a = (r >>>= 0) - (e >>>= 0), s = Math.min(o, a), f = this.slice(n, i), c = t.slice(e, r), l = 0; l < s; ++l) if (f[l] !== c[l]) {
+            o = f[l], a = c[l];
+            break;
+          }
+
+          return o < a ? -1 : a < o ? 1 : 0;
+        }, u.prototype.includes = function (t, e, r) {
+          return -1 !== this.indexOf(t, e, r);
+        }, u.prototype.indexOf = function (t, e, r) {
+          return y(this, t, e, r, !0);
+        }, u.prototype.lastIndexOf = function (t, e, r) {
+          return y(this, t, e, r, !1);
+        }, u.prototype.write = function (t, e, r, n) {
+          if (void 0 === e) n = "utf8", r = this.length, e = 0;else if (void 0 === r && "string" == typeof e) n = e, r = this.length, e = 0;else {
+            if (!isFinite(e)) throw new Error("Buffer.write(string, encoding, offset[, length]) is no longer supported");
+            e |= 0, isFinite(r) ? (r |= 0, void 0 === n && (n = "utf8")) : (n = r, r = void 0);
+          }
+          var i = this.length - e;
+          if ((void 0 === r || r > i) && (r = i), t.length > 0 && (r < 0 || e < 0) || e > this.length) throw new RangeError("Attempt to write outside buffer bounds");
+          n || (n = "utf8");
+
+          for (var o = !1;;) switch (n) {
+            case "hex":
+              return b(this, t, e, r);
+
+            case "utf8":
+            case "utf-8":
+              return _(this, t, e, r);
+
+            case "ascii":
+              return w(this, t, e, r);
+
+            case "latin1":
+            case "binary":
+              return x(this, t, e, r);
+
+            case "base64":
+              return E(this, t, e, r);
+
+            case "ucs2":
+            case "ucs-2":
+            case "utf16le":
+            case "utf-16le":
+              return S(this, t, e, r);
+
+            default:
+              if (o) throw new TypeError("Unknown encoding: " + n);
+              n = ("" + n).toLowerCase(), o = !0;
+          }
+        }, u.prototype.toJSON = function () {
+          return {
+            type: "Buffer",
+            data: Array.prototype.slice.call(this._arr || this, 0)
+          };
+        };
+        var C = 4096;
+
+        function T(t, e, r) {
+          var n = "";
+          r = Math.min(t.length, r);
+
+          for (var i = e; i < r; ++i) n += String.fromCharCode(127 & t[i]);
+
+          return n;
+        }
+
+        function R(t, e, r) {
+          var n = "";
+          r = Math.min(t.length, r);
+
+          for (var i = e; i < r; ++i) n += String.fromCharCode(t[i]);
+
+          return n;
+        }
+
+        function O(t, e, r) {
+          var n = t.length;
+          (!e || e < 0) && (e = 0), (!r || r < 0 || r > n) && (r = n);
+
+          for (var i = "", o = e; o < r; ++o) i += U(t[o]);
+
+          return i;
+        }
+
+        function I(t, e, r) {
+          for (var n = t.slice(e, r), i = "", o = 0; o < n.length; o += 2) i += String.fromCharCode(n[o] + 256 * n[o + 1]);
+
+          return i;
+        }
+
+        function L(t, e, r) {
+          if (t % 1 != 0 || t < 0) throw new RangeError("offset is not uint");
+          if (t + e > r) throw new RangeError("Trying to access beyond buffer length");
+        }
+
+        function B(t, e, r, n, i, o) {
+          if (!u.isBuffer(t)) throw new TypeError('"buffer" argument must be a Buffer instance');
+          if (e > i || e < o) throw new RangeError('"value" argument is out of bounds');
+          if (r + n > t.length) throw new RangeError("Index out of range");
+        }
+
+        function P(t, e, r, n) {
+          e < 0 && (e = 65535 + e + 1);
+
+          for (var i = 0, o = Math.min(t.length - r, 2); i < o; ++i) t[r + i] = (e & 255 << 8 * (n ? i : 1 - i)) >>> 8 * (n ? i : 1 - i);
+        }
+
+        function F(t, e, r, n) {
+          e < 0 && (e = 4294967295 + e + 1);
+
+          for (var i = 0, o = Math.min(t.length - r, 4); i < o; ++i) t[r + i] = e >>> 8 * (n ? i : 3 - i) & 255;
+        }
+
+        function N(t, e, r, n, i, o) {
+          if (r + n > t.length) throw new RangeError("Index out of range");
+          if (r < 0) throw new RangeError("Index out of range");
+        }
+
+        function M(t, e, r, n, o) {
+          return o || N(t, 0, r, 4), i.write(t, e, r, n, 23, 4), r + 4;
+        }
+
+        function j(t, e, r, n, o) {
+          return o || N(t, 0, r, 8), i.write(t, e, r, n, 52, 8), r + 8;
+        }
+
+        u.prototype.slice = function (t, e) {
+          var r,
+              n = this.length;
+          if ((t = ~~t) < 0 ? (t += n) < 0 && (t = 0) : t > n && (t = n), (e = void 0 === e ? n : ~~e) < 0 ? (e += n) < 0 && (e = 0) : e > n && (e = n), e < t && (e = t), u.TYPED_ARRAY_SUPPORT) (r = this.subarray(t, e)).__proto__ = u.prototype;else {
+            var i = e - t;
+            r = new u(i, void 0);
+
+            for (var o = 0; o < i; ++o) r[o] = this[o + t];
+          }
+          return r;
+        }, u.prototype.readUIntLE = function (t, e, r) {
+          t |= 0, e |= 0, r || L(t, e, this.length);
+
+          for (var n = this[t], i = 1, o = 0; ++o < e && (i *= 256);) n += this[t + o] * i;
+
+          return n;
+        }, u.prototype.readUIntBE = function (t, e, r) {
+          t |= 0, e |= 0, r || L(t, e, this.length);
+
+          for (var n = this[t + --e], i = 1; e > 0 && (i *= 256);) n += this[t + --e] * i;
+
+          return n;
+        }, u.prototype.readUInt8 = function (t, e) {
+          return e || L(t, 1, this.length), this[t];
+        }, u.prototype.readUInt16LE = function (t, e) {
+          return e || L(t, 2, this.length), this[t] | this[t + 1] << 8;
+        }, u.prototype.readUInt16BE = function (t, e) {
+          return e || L(t, 2, this.length), this[t] << 8 | this[t + 1];
+        }, u.prototype.readUInt32LE = function (t, e) {
+          return e || L(t, 4, this.length), (this[t] | this[t + 1] << 8 | this[t + 2] << 16) + 16777216 * this[t + 3];
+        }, u.prototype.readUInt32BE = function (t, e) {
+          return e || L(t, 4, this.length), 16777216 * this[t] + (this[t + 1] << 16 | this[t + 2] << 8 | this[t + 3]);
+        }, u.prototype.readIntLE = function (t, e, r) {
+          t |= 0, e |= 0, r || L(t, e, this.length);
+
+          for (var n = this[t], i = 1, o = 0; ++o < e && (i *= 256);) n += this[t + o] * i;
+
+          return n >= (i *= 128) && (n -= Math.pow(2, 8 * e)), n;
+        }, u.prototype.readIntBE = function (t, e, r) {
+          t |= 0, e |= 0, r || L(t, e, this.length);
+
+          for (var n = e, i = 1, o = this[t + --n]; n > 0 && (i *= 256);) o += this[t + --n] * i;
+
+          return o >= (i *= 128) && (o -= Math.pow(2, 8 * e)), o;
+        }, u.prototype.readInt8 = function (t, e) {
+          return e || L(t, 1, this.length), 128 & this[t] ? -1 * (255 - this[t] + 1) : this[t];
+        }, u.prototype.readInt16LE = function (t, e) {
+          e || L(t, 2, this.length);
+          var r = this[t] | this[t + 1] << 8;
+          return 32768 & r ? 4294901760 | r : r;
+        }, u.prototype.readInt16BE = function (t, e) {
+          e || L(t, 2, this.length);
+          var r = this[t + 1] | this[t] << 8;
+          return 32768 & r ? 4294901760 | r : r;
+        }, u.prototype.readInt32LE = function (t, e) {
+          return e || L(t, 4, this.length), this[t] | this[t + 1] << 8 | this[t + 2] << 16 | this[t + 3] << 24;
+        }, u.prototype.readInt32BE = function (t, e) {
+          return e || L(t, 4, this.length), this[t] << 24 | this[t + 1] << 16 | this[t + 2] << 8 | this[t + 3];
+        }, u.prototype.readFloatLE = function (t, e) {
+          return e || L(t, 4, this.length), i.read(this, t, !0, 23, 4);
+        }, u.prototype.readFloatBE = function (t, e) {
+          return e || L(t, 4, this.length), i.read(this, t, !1, 23, 4);
+        }, u.prototype.readDoubleLE = function (t, e) {
+          return e || L(t, 8, this.length), i.read(this, t, !0, 52, 8);
+        }, u.prototype.readDoubleBE = function (t, e) {
+          return e || L(t, 8, this.length), i.read(this, t, !1, 52, 8);
+        }, u.prototype.writeUIntLE = function (t, e, r, n) {
+          (t = +t, e |= 0, r |= 0, n) || B(this, t, e, r, Math.pow(2, 8 * r) - 1, 0);
+          var i = 1,
+              o = 0;
+
+          for (this[e] = 255 & t; ++o < r && (i *= 256);) this[e + o] = t / i & 255;
+
+          return e + r;
+        }, u.prototype.writeUIntBE = function (t, e, r, n) {
+          (t = +t, e |= 0, r |= 0, n) || B(this, t, e, r, Math.pow(2, 8 * r) - 1, 0);
+          var i = r - 1,
+              o = 1;
+
+          for (this[e + i] = 255 & t; --i >= 0 && (o *= 256);) this[e + i] = t / o & 255;
+
+          return e + r;
+        }, u.prototype.writeUInt8 = function (t, e, r) {
+          return t = +t, e |= 0, r || B(this, t, e, 1, 255, 0), u.TYPED_ARRAY_SUPPORT || (t = Math.floor(t)), this[e] = 255 & t, e + 1;
+        }, u.prototype.writeUInt16LE = function (t, e, r) {
+          return t = +t, e |= 0, r || B(this, t, e, 2, 65535, 0), u.TYPED_ARRAY_SUPPORT ? (this[e] = 255 & t, this[e + 1] = t >>> 8) : P(this, t, e, !0), e + 2;
+        }, u.prototype.writeUInt16BE = function (t, e, r) {
+          return t = +t, e |= 0, r || B(this, t, e, 2, 65535, 0), u.TYPED_ARRAY_SUPPORT ? (this[e] = t >>> 8, this[e + 1] = 255 & t) : P(this, t, e, !1), e + 2;
+        }, u.prototype.writeUInt32LE = function (t, e, r) {
+          return t = +t, e |= 0, r || B(this, t, e, 4, 4294967295, 0), u.TYPED_ARRAY_SUPPORT ? (this[e + 3] = t >>> 24, this[e + 2] = t >>> 16, this[e + 1] = t >>> 8, this[e] = 255 & t) : F(this, t, e, !0), e + 4;
+        }, u.prototype.writeUInt32BE = function (t, e, r) {
+          return t = +t, e |= 0, r || B(this, t, e, 4, 4294967295, 0), u.TYPED_ARRAY_SUPPORT ? (this[e] = t >>> 24, this[e + 1] = t >>> 16, this[e + 2] = t >>> 8, this[e + 3] = 255 & t) : F(this, t, e, !1), e + 4;
+        }, u.prototype.writeIntLE = function (t, e, r, n) {
+          if (t = +t, e |= 0, !n) {
+            var i = Math.pow(2, 8 * r - 1);
+            B(this, t, e, r, i - 1, -i);
+          }
+
+          var o = 0,
+              a = 1,
+              s = 0;
+
+          for (this[e] = 255 & t; ++o < r && (a *= 256);) t < 0 && 0 === s && 0 !== this[e + o - 1] && (s = 1), this[e + o] = (t / a >> 0) - s & 255;
+
+          return e + r;
+        }, u.prototype.writeIntBE = function (t, e, r, n) {
+          if (t = +t, e |= 0, !n) {
+            var i = Math.pow(2, 8 * r - 1);
+            B(this, t, e, r, i - 1, -i);
+          }
+
+          var o = r - 1,
+              a = 1,
+              s = 0;
+
+          for (this[e + o] = 255 & t; --o >= 0 && (a *= 256);) t < 0 && 0 === s && 0 !== this[e + o + 1] && (s = 1), this[e + o] = (t / a >> 0) - s & 255;
+
+          return e + r;
+        }, u.prototype.writeInt8 = function (t, e, r) {
+          return t = +t, e |= 0, r || B(this, t, e, 1, 127, -128), u.TYPED_ARRAY_SUPPORT || (t = Math.floor(t)), t < 0 && (t = 255 + t + 1), this[e] = 255 & t, e + 1;
+        }, u.prototype.writeInt16LE = function (t, e, r) {
+          return t = +t, e |= 0, r || B(this, t, e, 2, 32767, -32768), u.TYPED_ARRAY_SUPPORT ? (this[e] = 255 & t, this[e + 1] = t >>> 8) : P(this, t, e, !0), e + 2;
+        }, u.prototype.writeInt16BE = function (t, e, r) {
+          return t = +t, e |= 0, r || B(this, t, e, 2, 32767, -32768), u.TYPED_ARRAY_SUPPORT ? (this[e] = t >>> 8, this[e + 1] = 255 & t) : P(this, t, e, !1), e + 2;
+        }, u.prototype.writeInt32LE = function (t, e, r) {
+          return t = +t, e |= 0, r || B(this, t, e, 4, 2147483647, -2147483648), u.TYPED_ARRAY_SUPPORT ? (this[e] = 255 & t, this[e + 1] = t >>> 8, this[e + 2] = t >>> 16, this[e + 3] = t >>> 24) : F(this, t, e, !0), e + 4;
+        }, u.prototype.writeInt32BE = function (t, e, r) {
+          return t = +t, e |= 0, r || B(this, t, e, 4, 2147483647, -2147483648), t < 0 && (t = 4294967295 + t + 1), u.TYPED_ARRAY_SUPPORT ? (this[e] = t >>> 24, this[e + 1] = t >>> 16, this[e + 2] = t >>> 8, this[e + 3] = 255 & t) : F(this, t, e, !1), e + 4;
+        }, u.prototype.writeFloatLE = function (t, e, r) {
+          return M(this, t, e, !0, r);
+        }, u.prototype.writeFloatBE = function (t, e, r) {
+          return M(this, t, e, !1, r);
+        }, u.prototype.writeDoubleLE = function (t, e, r) {
+          return j(this, t, e, !0, r);
+        }, u.prototype.writeDoubleBE = function (t, e, r) {
+          return j(this, t, e, !1, r);
+        }, u.prototype.copy = function (t, e, r, n) {
+          if (r || (r = 0), n || 0 === n || (n = this.length), e >= t.length && (e = t.length), e || (e = 0), n > 0 && n < r && (n = r), n === r) return 0;
+          if (0 === t.length || 0 === this.length) return 0;
+          if (e < 0) throw new RangeError("targetStart out of bounds");
+          if (r < 0 || r >= this.length) throw new RangeError("sourceStart out of bounds");
+          if (n < 0) throw new RangeError("sourceEnd out of bounds");
+          n > this.length && (n = this.length), t.length - e < n - r && (n = t.length - e + r);
+          var i,
+              o = n - r;
+          if (this === t && r < e && e < n) for (i = o - 1; i >= 0; --i) t[i + e] = this[i + r];else if (o < 1e3 || !u.TYPED_ARRAY_SUPPORT) for (i = 0; i < o; ++i) t[i + e] = this[i + r];else Uint8Array.prototype.set.call(t, this.subarray(r, r + o), e);
+          return o;
+        }, u.prototype.fill = function (t, e, r, n) {
+          if ("string" == typeof t) {
+            if ("string" == typeof e ? (n = e, e = 0, r = this.length) : "string" == typeof r && (n = r, r = this.length), 1 === t.length) {
+              var i = t.charCodeAt(0);
+              i < 256 && (t = i);
+            }
+
+            if (void 0 !== n && "string" != typeof n) throw new TypeError("encoding must be a string");
+            if ("string" == typeof n && !u.isEncoding(n)) throw new TypeError("Unknown encoding: " + n);
+          } else "number" == typeof t && (t &= 255);
+
+          if (e < 0 || this.length < e || this.length < r) throw new RangeError("Out of range index");
+          if (r <= e) return this;
+          var o;
+          if (e >>>= 0, r = void 0 === r ? this.length : r >>> 0, t || (t = 0), "number" == typeof t) for (o = e; o < r; ++o) this[o] = t;else {
+            var a = u.isBuffer(t) ? t : D(new u(t, n).toString()),
+                s = a.length;
+
+            for (o = 0; o < r - e; ++o) this[o + e] = a[o % s];
+          }
+          return this;
+        };
+        var z = /[^+\/0-9A-Za-z-_]/g;
+
+        function U(t) {
+          return t < 16 ? "0" + t.toString(16) : t.toString(16);
+        }
+
+        function D(t, e) {
+          var r;
+          e = e || 1 / 0;
+
+          for (var n = t.length, i = null, o = [], a = 0; a < n; ++a) {
+            if ((r = t.charCodeAt(a)) > 55295 && r < 57344) {
+              if (!i) {
+                if (r > 56319) {
+                  (e -= 3) > -1 && o.push(239, 191, 189);
+                  continue;
+                }
+
+                if (a + 1 === n) {
+                  (e -= 3) > -1 && o.push(239, 191, 189);
+                  continue;
+                }
+
+                i = r;
+                continue;
+              }
+
+              if (r < 56320) {
+                (e -= 3) > -1 && o.push(239, 191, 189), i = r;
+                continue;
+              }
+
+              r = 65536 + (i - 55296 << 10 | r - 56320);
+            } else i && (e -= 3) > -1 && o.push(239, 191, 189);
+
+            if (i = null, r < 128) {
+              if ((e -= 1) < 0) break;
+              o.push(r);
+            } else if (r < 2048) {
+              if ((e -= 2) < 0) break;
+              o.push(r >> 6 | 192, 63 & r | 128);
+            } else if (r < 65536) {
+              if ((e -= 3) < 0) break;
+              o.push(r >> 12 | 224, r >> 6 & 63 | 128, 63 & r | 128);
+            } else {
+              if (!(r < 1114112)) throw new Error("Invalid code point");
+              if ((e -= 4) < 0) break;
+              o.push(r >> 18 | 240, r >> 12 & 63 | 128, r >> 6 & 63 | 128, 63 & r | 128);
+            }
+          }
+
+          return o;
+        }
+
+        function q(t) {
+          return n.toByteArray(function (t) {
+            if ((t = function (t) {
+              return t.trim ? t.trim() : t.replace(/^\s+|\s+$/g, "");
+            }(t).replace(z, "")).length < 2) return "";
+
+            for (; t.length % 4 != 0;) t += "=";
+
+            return t;
+          }(t));
+        }
+
+        function Z(t, e, r, n) {
+          for (var i = 0; i < n && !(i + r >= e.length || i >= t.length); ++i) e[i + r] = t[i];
+
+          return i;
+        }
+      }).call(this, r(23));
+    }, function (t, e, r) {
+      var n = r(17),
+          i = r(21),
+          o = r(43);
+      t.exports = n ? function (t, e, r) {
+        return i.f(t, e, o(1, r));
+      } : function (t, e, r) {
+        return t[e] = r, t;
+      };
+    }, function (t, e, r) {
+      var n = r(17),
+          i = r(106),
+          o = r(2),
+          a = r(62),
+          s = Object.defineProperty;
+      e.f = n ? s : function (t, e, r) {
+        if (o(t), e = a(e, !0), o(r), i) try {
+          return s(t, e, r);
+        } catch (t) {}
+        if ("get" in r || "set" in r) throw TypeError("Accessors not supported");
+        return "value" in r && (t[e] = r.value), t;
+      };
+    }, function (t, e, r) {
+      var n = r(49);
+
+      t.exports = function (t) {
+        return Object(n(t));
+      };
+    }, function (t, e) {
+      var r;
+
+      r = function () {
+        return this;
+      }();
+
+      try {
+        r = r || new Function("return this")();
+      } catch (t) {
+        "object" == typeof window && (r = window);
+      }
+
+      t.exports = r;
+    }, function (t, e) {
+      var r = {}.hasOwnProperty;
+
+      t.exports = function (t, e) {
+        return r.call(t, e);
+      };
+    }, function (t, e, r) {
+      var n = r(4),
+          i = r(142);
+      t.exports = n ? i : function (t) {
+        return Map.prototype.entries.call(t);
+      };
+    }, function (t, e, r) {
+      var n = r(3),
+          i = r(13),
+          o = function (t) {
+        return "function" == typeof t ? t : void 0;
+      };
+
+      t.exports = function (t, e) {
+        return arguments.length < 2 ? o(n[t]) || o(i[t]) : n[t] && n[t][e] || i[t] && i[t][e];
+      };
+    }, function (t, e, r) {
+      var n = r(255),
+          i = r(139);
+
+      function o(e) {
+        return t.exports = o = i ? n : function (t) {
+          return t.__proto__ || n(t);
+        }, o(e);
+      }
+
+      t.exports = o;
+    }, function (t, e, r) {
+      var n = r(60),
+          i = r(49);
+
+      t.exports = function (t) {
+        return n(i(t));
+      };
+    }, function (t, e, r) {
+      var n = r(83),
+          i = Math.min;
+
+      t.exports = function (t) {
+        return t > 0 ? i(n(t), 9007199254740991) : 0;
+      };
+    }, function (t, e, r) {
+      t.exports = r(184);
+    }, function (t, e, r) {
+      var n = r(185);
+
+      function i(t, e, r, i, o, a, s) {
+        try {
+          var u = t[a](s),
+              f = u.value;
+        } catch (t) {
+          return void r(t);
+        }
+
+        u.done ? e(f) : n.resolve(f).then(i, o);
+      }
+
+      t.exports = function (t) {
+        return function () {
+          var e = this,
+              r = arguments;
+          return new n(function (n, o) {
+            var a = t.apply(e, r);
+
+            function s(t) {
+              i(a, n, o, s, u, "next", t);
+            }
+
+            function u(t) {
+              i(a, n, o, s, u, "throw", t);
+            }
+
+            s(void 0);
+          });
+        };
+      };
+    }, function (t, e, r) {
+      var n = r(225),
+          i = r(254);
+
+      t.exports = function (t, e) {
+        return !e || "object" !== n(e) && "function" != typeof e ? i(t) : e;
+      };
+    }, function (t, e, r) {
+      var n = r(140),
+          i = r(96);
+
+      t.exports = function (t, e) {
+        if ("function" != typeof e && null !== e) throw new TypeError("Super expression must either be null or a function");
+        t.prototype = n(e && e.prototype, {
+          constructor: {
+            value: t,
+            writable: !0,
+            configurable: !0
+          }
+        }), e && i(t, e);
+      };
+    }, function (t, e) {
+      var r = {}.toString;
+
+      t.exports = function (t) {
+        return r.call(t).slice(8, -1);
+      };
+    }, function (t, e) {
+      t.exports = {};
+    }, function (t, e, r) {
+      var n = r(21).f,
+          i = r(20),
+          o = r(24),
+          a = r(174),
+          s = r(6)("toStringTag"),
+          u = a !== {}.toString;
+
+      t.exports = function (t, e, r, f) {
+        if (t) {
+          var c = r ? t : t.prototype;
+          o(c, s) || n(c, s, {
+            configurable: !0,
+            value: e
+          }), f && u && i(c, "toString", a);
+        }
+      };
+    }, function (t, e, r) {
+      t.exports = r(181);
+    }, function (t, e) {
+      var r,
+          n,
+          i = t.exports = {};
+
+      function o() {
+        throw new Error("setTimeout has not been defined");
+      }
+
+      function a() {
+        throw new Error("clearTimeout has not been defined");
+      }
+
+      function s(t) {
+        if (r === setTimeout) return setTimeout(t, 0);
+        if ((r === o || !r) && setTimeout) return r = setTimeout, setTimeout(t, 0);
+
+        try {
+          return r(t, 0);
+        } catch (e) {
+          try {
+            return r.call(null, t, 0);
+          } catch (e) {
+            return r.call(this, t, 0);
+          }
+        }
+      }
+
+      !function () {
+        try {
+          r = "function" == typeof setTimeout ? setTimeout : o;
+        } catch (t) {
+          r = o;
+        }
+
+        try {
+          n = "function" == typeof clearTimeout ? clearTimeout : a;
+        } catch (t) {
+          n = a;
+        }
+      }();
+      var u,
+          f = [],
+          c = !1,
+          l = -1;
+
+      function h() {
+        c && u && (c = !1, u.length ? f = u.concat(f) : l = -1, f.length && d());
+      }
+
+      function d() {
+        if (!c) {
+          var t = s(h);
+          c = !0;
+
+          for (var e = f.length; e;) {
+            for (u = f, f = []; ++l < e;) u && u[l].run();
+
+            l = -1, e = f.length;
+          }
+
+          u = null, c = !1, function (t) {
+            if (n === clearTimeout) return clearTimeout(t);
+            if ((n === a || !n) && clearTimeout) return n = clearTimeout, clearTimeout(t);
+
+            try {
+              n(t);
+            } catch (e) {
+              try {
+                return n.call(null, t);
+              } catch (e) {
+                return n.call(this, t);
+              }
+            }
+          }(t);
+        }
+      }
+
+      function p(t, e) {
+        this.fun = t, this.array = e;
+      }
+
+      function g() {}
+
+      i.nextTick = function (t) {
+        var e = new Array(arguments.length - 1);
+        if (arguments.length > 1) for (var r = 1; r < arguments.length; r++) e[r - 1] = arguments[r];
+        f.push(new p(t, e)), 1 !== f.length || c || s(d);
+      }, p.prototype.run = function () {
+        this.fun.apply(null, this.array);
+      }, i.title = "browser", i.browser = !0, i.env = {}, i.argv = [], i.version = "", i.versions = {}, i.on = g, i.addListener = g, i.once = g, i.off = g, i.removeListener = g, i.removeAllListeners = g, i.emit = g, i.prependListener = g, i.prependOnceListener = g, i.listeners = function (t) {
+        return [];
+      }, i.binding = function (t) {
+        throw new Error("process.binding is not supported");
+      }, i.cwd = function () {
+        return "/";
+      }, i.chdir = function (t) {
+        throw new Error("process.chdir is not supported");
+      }, i.umask = function () {
+        return 0;
+      };
+    }, function (t, e, r) {
+
+      var n = r(70),
+          i = Object.keys || function (t) {
+        var e = [];
+
+        for (var r in t) e.push(r);
+
+        return e;
+      };
+
+      t.exports = l;
+      var o = r(57);
+      o.inherits = r(47);
+      var a = r(127),
+          s = r(93);
+      o.inherits(l, a);
+
+      for (var u = i(s.prototype), f = 0; f < u.length; f++) {
+        var c = u[f];
+        l.prototype[c] || (l.prototype[c] = s.prototype[c]);
+      }
+
+      function l(t) {
+        if (!(this instanceof l)) return new l(t);
+        a.call(this, t), s.call(this, t), t && !1 === t.readable && (this.readable = !1), t && !1 === t.writable && (this.writable = !1), this.allowHalfOpen = !0, t && !1 === t.allowHalfOpen && (this.allowHalfOpen = !1), this.once("end", h);
+      }
+
+      function h() {
+        this.allowHalfOpen || this._writableState.ended || n.nextTick(d, this);
+      }
+
+      function d(t) {
+        t.end();
+      }
+
+      Object.defineProperty(l.prototype, "writableHighWaterMark", {
+        enumerable: !1,
+        get: function () {
+          return this._writableState.highWaterMark;
+        }
+      }), Object.defineProperty(l.prototype, "destroyed", {
+        get: function () {
+          return void 0 !== this._readableState && void 0 !== this._writableState && this._readableState.destroyed && this._writableState.destroyed;
+        },
+        set: function (t) {
+          void 0 !== this._readableState && void 0 !== this._writableState && (this._readableState.destroyed = t, this._writableState.destroyed = t);
+        }
+      }), l.prototype._destroy = function (t, e) {
+        this.push(null), this.end(), n.nextTick(e, t);
+      };
+    }, function (t, e, r) {
+
+      var n = r(1),
+          i = n(r(7)),
+          o = n(r(10)),
+          a = r(9).CramBufferOverrunError,
+          s = {
+        int: !0,
+        byte: !0,
+        long: !0,
+        byteArray: !0,
+        byteArrayBlock: !0
+      },
+          u = function () {
+        function t() {
+          var e = arguments.length > 0 && void 0 !== arguments[0] ? arguments[0] : {},
+              r = arguments.length > 1 ? arguments[1] : void 0;
+          if ((0, i.default)(this, t), this.parameters = e, this.dataType = r, !r) throw new TypeError("must provide a data type to codec constructor");
+          if (!s[r]) throw new TypeError("invalid data type ".concat(r));
+        }
+
+        return (0, o.default)(t, [{
+          key: "_getBits",
+          value: function (t, e, r) {
+            var n = 0;
+            if (e.bytePosition + (7 - e.bitPosition + r) / 8 > t.length) throw new a("read error during decoding. the file seems to be truncated.");
+
+            for (var i = r; i; i -= 1) n <<= 1, n |= t[e.bytePosition] >> e.bitPosition & 1, e.bitPosition -= 1, e.bitPosition < 0 && (e.bytePosition += 1), e.bitPosition &= 7;
+
+            return n;
+          }
+        }]), t;
+      }();
+
+      t.exports = u;
+    }, function (t, e, r) {
+      r(168);
+      var n = r(176),
+          i = r(13),
+          o = r(20),
+          a = r(35),
+          s = r(6)("toStringTag");
+
+      for (var u in n) {
+        var f = i[u],
+            c = f && f.prototype;
+        c && !c[s] && o(c, s, u), a[u] = a.Array;
+      }
+    }, function (t, e, r) {
+      var n,
+          i,
+          o,
+          a = r(169),
+          s = r(13),
+          u = r(14),
+          f = r(20),
+          c = r(24),
+          l = r(63),
+          h = r(50),
+          d = s.WeakMap;
+
+      if (a) {
+        var p = new d(),
+            g = p.get,
+            v = p.has,
+            y = p.set;
+        n = function (t, e) {
+          return y.call(p, t, e), e;
+        }, i = function (t) {
+          return g.call(p, t) || {};
+        }, o = function (t) {
+          return v.call(p, t);
+        };
+      } else {
+        var m = l("state");
+        h[m] = !0, n = function (t, e) {
+          return f(t, m, e), e;
+        }, i = function (t) {
+          return c(t, m) ? t[m] : {};
+        }, o = function (t) {
+          return c(t, m);
+        };
+      }
+
+      t.exports = {
+        set: n,
+        get: i,
+        has: o,
+        enforce: function (t) {
+          return o(t) ? i(t) : n(t, {});
+        },
+        getterFor: function (t) {
+          return function (e) {
+            var r;
+            if (!u(e) || (r = i(e)).type !== t) throw TypeError("Incompatible receiver, " + t + " required");
+            return r;
+          };
+        }
+      };
+    }, function (t, e) {
+      t.exports = function (t, e) {
+        return {
+          enumerable: !(1 & t),
+          configurable: !(2 & t),
+          writable: !(4 & t),
+          value: e
+        };
+      };
+    }, function (t, e, r) {
+      var n = r(2),
+          i = r(173),
+          o = r(85),
+          a = r(50),
+          s = r(112),
+          u = r(79),
+          f = r(63)("IE_PROTO"),
+          c = function () {},
+          l = function () {
+        var t,
+            e = u("iframe"),
+            r = o.length;
+
+        for (e.style.display = "none", s.appendChild(e), e.src = String("javascript:"), (t = e.contentWindow.document).open(), t.write("<script>document.F=Object<\/script>"), t.close(), l = t.F; r--;) delete l.prototype[o[r]];
+
+        return l();
+      };
+
+      t.exports = Object.create || function (t, e) {
+        var r;
+        return null !== t ? (c.prototype = n(t), r = new c(), c.prototype = null, r[f] = t) : r = l(), void 0 === e ? r : i(r, e);
+      }, a[f] = !0;
+    }, function (t, e, r) {
+      var n = r(15),
+          i = r(60),
+          o = r(22),
+          a = r(29),
+          s = r(113),
+          u = [].push,
+          f = function (t) {
+        var e = 1 == t,
+            r = 2 == t,
+            f = 3 == t,
+            c = 4 == t,
+            l = 6 == t,
+            h = 5 == t || l;
+        return function (d, p, g, v) {
+          for (var y, m, b = o(d), _ = i(b), w = n(p, g, 3), x = a(_.length), E = 0, S = v || s, k = e ? S(d, x) : r ? S(d, 0) : void 0; x > E; E++) if ((h || E in _) && (m = w(y = _[E], E, b), t)) if (e) k[E] = m;else if (m) switch (t) {
+            case 3:
+              return !0;
+
+            case 5:
+              return y;
+
+            case 6:
+              return E;
+
+            case 2:
+              u.call(k, y);
+          } else if (c) return !1;
+
+          return l ? -1 : f || c ? c : k;
+        };
+      };
+
+      t.exports = {
+        forEach: f(0),
+        map: f(1),
+        filter: f(2),
+        some: f(3),
+        every: f(4),
+        find: f(5),
+        findIndex: f(6)
+      };
+    }, function (t, e, r) {
+
+      var n = r(187).charAt,
+          i = r(42),
+          o = r(80),
+          a = i.set,
+          s = i.getterFor("String Iterator");
+      o(String, "String", function (t) {
+        a(this, {
+          type: "String Iterator",
+          string: String(t),
+          index: 0
+        });
+      }, function () {
+        var t,
+            e = s(this),
+            r = e.string,
+            i = e.index;
+        return i >= r.length ? {
+          value: void 0,
+          done: !0
+        } : (t = n(r, i), e.index += t.length, {
+          value: t,
+          done: !1
+        });
+      });
+    }, function (t, e) {
+      "function" == typeof Object.create ? t.exports = function (t, e) {
+        e && (t.super_ = e, t.prototype = Object.create(e.prototype, {
+          constructor: {
+            value: t,
+            enumerable: !1,
+            writable: !0,
+            configurable: !0
+          }
+        }));
+      } : t.exports = function (t, e) {
+        if (e) {
+          t.super_ = e;
+
+          var r = function () {};
+
+          r.prototype = e.prototype, t.prototype = new r(), t.prototype.constructor = t;
+        }
+      };
+    }, function (t, e, r) {
+      var n = r(157),
+          i = r(384),
+          o = r(158);
+
+      t.exports = function (t, e) {
+        return n(t) || i(t, e) || o();
+      };
+    }, function (t, e) {
+      t.exports = function (t) {
+        if (null == t) throw TypeError("Can't call method on " + t);
+        return t;
+      };
+    }, function (t, e) {
+      t.exports = {};
+    }, function (t, e, r) {
+      var n = r(111),
+          i = r(85);
+
+      t.exports = Object.keys || function (t) {
+        return n(t, i);
+      };
+    }, function (t, e, r) {
+      var n = r(20);
+
+      t.exports = function (t, e, r, i) {
+        i && i.enumerable ? t[e] = r : n(t, e, r);
+      };
+    }, function (t, e, r) {
+      var n = r(34);
+
+      t.exports = Array.isArray || function (t) {
+        return "Array" == n(t);
+      };
+    }, function (t, e, r) {
+
+      var n = r(12);
+
+      t.exports = function (t, e) {
+        var r = [][t];
+        return !r || !n(function () {
+          r.call(null, e || function () {
+            throw 1;
+          }, 1);
+        });
+      };
+    }, function (t, e, r) {
+      var n = r(2),
+          i = r(5),
+          o = r(6)("species");
+
+      t.exports = function (t, e) {
+        var r,
+            a = n(t).constructor;
+        return void 0 === a || null == (r = n(a)[o]) ? e : i(r);
+      };
+    }, function (t, e, r) {
+
+      var n = r(5),
+          i = function (t) {
+        var e, r;
+        this.promise = new t(function (t, n) {
+          if (void 0 !== e || void 0 !== r) throw TypeError("Bad Promise constructor");
+          e = t, r = n;
+        }), this.resolve = n(e), this.reject = n(r);
+      };
+
+      t.exports.f = function (t) {
+        return new i(t);
+      };
+    }, function (t, e, r) {
+      (function (t) {
+        function r(t) {
+          return Object.prototype.toString.call(t);
+        }
+
+        e.isArray = function (t) {
+          return Array.isArray ? Array.isArray(t) : "[object Array]" === r(t);
+        }, e.isBoolean = function (t) {
+          return "boolean" == typeof t;
+        }, e.isNull = function (t) {
+          return null === t;
+        }, e.isNullOrUndefined = function (t) {
+          return null == t;
+        }, e.isNumber = function (t) {
+          return "number" == typeof t;
+        }, e.isString = function (t) {
+          return "string" == typeof t;
+        }, e.isSymbol = function (t) {
+          return "symbol" == typeof t;
+        }, e.isUndefined = function (t) {
+          return void 0 === t;
+        }, e.isRegExp = function (t) {
+          return "[object RegExp]" === r(t);
+        }, e.isObject = function (t) {
+          return "object" == typeof t && null !== t;
+        }, e.isDate = function (t) {
+          return "[object Date]" === r(t);
+        }, e.isError = function (t) {
+          return "[object Error]" === r(t) || t instanceof Error;
+        }, e.isFunction = function (t) {
+          return "function" == typeof t;
+        }, e.isPrimitive = function (t) {
+          return null === t || "boolean" == typeof t || "number" == typeof t || "string" == typeof t || "symbol" == typeof t || void 0 === t;
+        }, e.isBuffer = t.isBuffer;
+      }).call(this, r(19).Buffer);
+    }, function (t, e, r) {
+
+      var n = r(1)(r(76)),
+          i = r(331),
+          o = r(9).CramBufferOverrunError;
+      t.exports = {
+        itf8Size: function (t) {
+          return -128 & t ? -16384 & t ? -2097152 & t ? -268435456 & t ? 5 : 4 : 3 : 2 : 1;
+        },
+        parseItf8: function (t, e) {
+          var r,
+              n = e,
+              i = t[n];
+          if (i < 128 ? (r = i, n += 1) : i < 192 ? (r = 16383 & (i << 8 | t[n + 1]), n += 2) : i < 224 ? (r = 2097151 & (i << 16 | t[n + 1] << 8 | t[n + 2]), n += 3) : i < 240 ? (r = 268435455 & (i << 24 | t[n + 1] << 16 | t[n + 2] << 8 | t[n + 3]), n += 4) : (r = (15 & i) << 28 | t[n + 1] << 20 | t[n + 2] << 12 | t[n + 3] << 4 | 15 & t[n + 4], n += 5), n > t.length) throw new o("Attempted to read beyond end of buffer; this file seems truncated.");
+          return [r, n - e];
+        },
+        parseItem: function (t, e) {
+          var r = arguments.length > 2 && void 0 !== arguments[2] ? arguments[2] : 0,
+              n = arguments.length > 3 && void 0 !== arguments[3] ? arguments[3] : 0,
+              i = e.parse(t),
+              o = i.offset,
+              a = i.result;
+          return a._endPosition = o + n, a._size = o - r, a;
+        },
+        tinyMemoize: function (t, e) {
+          var r = t.prototype[e],
+              i = "_memo_".concat(e);
+
+          t.prototype[e] = function () {
+            var t = this;
+
+            if (!(i in this)) {
+              var e = r.call(this);
+              this[i] = e, n.default.resolve(e).catch(function () {
+                delete t[i];
+              });
+            }
+
+            return this[i];
+          };
+        },
+        sequenceMD5: function (t) {
+          return i(t.toUpperCase().replace(/[^\x21-\x7e]/g, ""));
+        }
+      };
+    }, function (t, e, r) {
+      var n = r(351),
+          i = r(152),
+          o = r(362);
+
+      t.exports = function (t) {
+        return n(t) || i(t) || o();
+      };
+    }, function (t, e, r) {
+      var n = r(12),
+          i = r(34),
+          o = "".split;
+      t.exports = n(function () {
+        return !Object("z").propertyIsEnumerable(0);
+      }) ? function (t) {
+        return "String" == i(t) ? o.call(t, "") : Object(t);
+      } : Object;
+    }, function (t, e, r) {
+      var n = r(13),
+          i = r(171),
+          o = r(4),
+          a = n["__core-js_shared__"] || i("__core-js_shared__", {});
+      (t.exports = function (t, e) {
+        return a[t] || (a[t] = void 0 !== e ? e : {});
+      })("versions", []).push({
+        version: "3.2.1",
+        mode: o ? "pure" : "global",
+        copyright: "© 2019 Denis Pushkarev (zloirock.ru)"
+      });
+    }, function (t, e, r) {
+      var n = r(14);
+
+      t.exports = function (t, e) {
+        if (!n(t)) return t;
+        var r, i;
+        if (e && "function" == typeof (r = t.toString) && !n(i = r.call(t))) return i;
+        if ("function" == typeof (r = t.valueOf) && !n(i = r.call(t))) return i;
+        if (!e && "function" == typeof (r = t.toString) && !n(i = r.call(t))) return i;
+        throw TypeError("Can't convert object to primitive value");
+      };
+    }, function (t, e, r) {
+      var n = r(61),
+          i = r(64),
+          o = n("keys");
+
+      t.exports = function (t) {
+        return o[t] || (o[t] = i(t));
+      };
+    }, function (t, e) {
+      var r = 0,
+          n = Math.random();
+
+      t.exports = function (t) {
+        return "Symbol(" + String(void 0 === t ? "" : t) + ")_" + (++r + n).toString(36);
+      };
+    }, function (t, e, r) {
+
+      var n = {}.propertyIsEnumerable,
+          i = Object.getOwnPropertyDescriptor,
+          o = i && !n.call({
+        1: 2
+      }, 1);
+      e.f = o ? function (t) {
+        var e = i(this, t);
+        return !!e && e.enumerable;
+      } : n;
+    }, function (t, e, r) {
+      var n = r(24),
+          i = r(22),
+          o = r(63),
+          a = r(109),
+          s = o("IE_PROTO"),
+          u = Object.prototype;
+      t.exports = a ? Object.getPrototypeOf : function (t) {
+        return t = i(t), n(t, s) ? t[s] : "function" == typeof t.constructor && t instanceof t.constructor ? t.constructor.prototype : t instanceof Object ? u : null;
+      };
+    }, function (t, e, r) {
+      var n = r(34),
+          i = r(6)("toStringTag"),
+          o = "Arguments" == n(function () {
+        return arguments;
+      }());
+
+      t.exports = function (t) {
+        var e, r, a;
+        return void 0 === t ? "Undefined" : null === t ? "Null" : "string" == typeof (r = function (t, e) {
+          try {
+            return t[e];
+          } catch (t) {}
+        }(e = Object(t), i)) ? r : o ? n(e) : "Object" == (a = n(e)) && "function" == typeof e.callee ? "Arguments" : a;
+      };
+    }, function (t, e, r) {
+      var n = r(12),
+          i = r(6)("species");
+
+      t.exports = function (t) {
+        return !n(function () {
+          var e = [];
+          return (e.constructor = {})[i] = function () {
+            return {
+              foo: 1
+            };
+          }, 1 !== e[t](Boolean).foo;
+        });
+      };
+    }, function (t, e) {
+      t.exports = function (t) {
+        try {
+          return {
+            error: !1,
+            value: t()
+          };
+        } catch (t) {
+          return {
+            error: !0,
+            value: t
+          };
+        }
+      };
+    }, function (t, e, r) {
+
+      (function (e) {
+        void 0 === e || !e.version || 0 === e.version.indexOf("v0.") || 0 === e.version.indexOf("v1.") && 0 !== e.version.indexOf("v1.8.") ? t.exports = {
+          nextTick: function (t, r, n, i) {
+            if ("function" != typeof t) throw new TypeError('"callback" argument must be a function');
+            var o,
+                a,
+                s = arguments.length;
+
+            switch (s) {
+              case 0:
+              case 1:
+                return e.nextTick(t);
+
+              case 2:
+                return e.nextTick(function () {
+                  t.call(null, r);
+                });
+
+              case 3:
+                return e.nextTick(function () {
+                  t.call(null, r, n);
+                });
+
+              case 4:
+                return e.nextTick(function () {
+                  t.call(null, r, n, i);
+                });
+
+              default:
+                for (o = new Array(s - 1), a = 0; a < o.length;) o[a++] = arguments[a];
+
+                return e.nextTick(function () {
+                  t.apply(null, o);
+                });
+            }
+          }
+        } : t.exports = e;
+      }).call(this, r(38));
+    }, function (t, e, r) {
+      var n = r(19),
+          i = n.Buffer;
+
+      function o(t, e) {
+        for (var r in t) e[r] = t[r];
+      }
+
+      function a(t, e, r) {
+        return i(t, e, r);
+      }
+
+      i.from && i.alloc && i.allocUnsafe && i.allocUnsafeSlow ? t.exports = n : (o(n, e), e.Buffer = a), o(i, a), a.from = function (t, e, r) {
+        if ("number" == typeof t) throw new TypeError("Argument must not be a number");
+        return i(t, e, r);
+      }, a.alloc = function (t, e, r) {
+        if ("number" != typeof t) throw new TypeError("Argument must be a number");
+        var n = i(t);
+        return void 0 !== e ? "string" == typeof r ? n.fill(e, r) : n.fill(e) : n.fill(0), n;
+      }, a.allocUnsafe = function (t) {
+        if ("number" != typeof t) throw new TypeError("Argument must be a number");
+        return i(t);
+      }, a.allocUnsafeSlow = function (t) {
+        if ("number" != typeof t) throw new TypeError("Argument must be a number");
+        return n.SlowBuffer(t);
+      };
+    }, function (t, e, r) {
+
+      var n = "undefined" != typeof Uint8Array && "undefined" != typeof Uint16Array && "undefined" != typeof Int32Array;
+
+      function i(t, e) {
+        return Object.prototype.hasOwnProperty.call(t, e);
+      }
+
+      e.assign = function (t) {
+        for (var e = Array.prototype.slice.call(arguments, 1); e.length;) {
+          var r = e.shift();
+
+          if (r) {
+            if ("object" != typeof r) throw new TypeError(r + "must be non-object");
+
+            for (var n in r) i(r, n) && (t[n] = r[n]);
+          }
+        }
+
+        return t;
+      }, e.shrinkBuf = function (t, e) {
+        return t.length === e ? t : t.subarray ? t.subarray(0, e) : (t.length = e, t);
+      };
+      var o = {
+        arraySet: function (t, e, r, n, i) {
+          if (e.subarray && t.subarray) t.set(e.subarray(r, r + n), i);else for (var o = 0; o < n; o++) t[i + o] = e[r + o];
+        },
+        flattenChunks: function (t) {
+          var e, r, n, i, o, a;
+
+          for (n = 0, e = 0, r = t.length; e < r; e++) n += t[e].length;
+
+          for (a = new Uint8Array(n), i = 0, e = 0, r = t.length; e < r; e++) o = t[e], a.set(o, i), i += o.length;
+
+          return a;
+        }
+      },
+          a = {
+        arraySet: function (t, e, r, n, i) {
+          for (var o = 0; o < n; o++) t[i + o] = e[r + o];
+        },
+        flattenChunks: function (t) {
+          return [].concat.apply([], t);
+        }
+      };
+      e.setTyped = function (t) {
+        t ? (e.Buf8 = Uint8Array, e.Buf16 = Uint16Array, e.Buf32 = Int32Array, e.assign(e, o)) : (e.Buf8 = Array, e.Buf16 = Array, e.Buf32 = Array, e.assign(e, a));
+      }, e.setTyped(n);
+    }, function (t, e, r) {
+
+      var n = r(1)(r(7)),
+          i = r(9).CramMalformedError,
+          o = r(74),
+          a = function t() {
+        (0, n.default)(this, t), this.F = void 0, this.C = void 0;
+      };
+
+      function s(t, e, r, n) {
+        return r * (t >> n) + (t & (1 << n) - 1) - e;
+      }
+
+      var u = {
+        FC: a,
+        AriDecoder: function t() {
+          (0, n.default)(this, t), this.fc = new Array(256);
+
+          for (var e = 0; e < this.fc.length; e += 1) this.fc[e] = new a();
+
+          this.R = null;
+        },
+        Symbol: function t() {
+          (0, n.default)(this, t), this.start = void 0, this.freq = void 0;
+        },
+        symbolInit: function (t, e, r) {
+          if (!(e <= 65536)) throw new i("assertion failed: start <= 1<<16");
+          if (!(r <= 65536 - e)) throw new i("assertion failed: freq <= 1<<16");
+          t.start = e, t.freq = r;
+        },
+        advanceStep: s,
+        advanceSymbolStep: function (t, e, r) {
+          return s(t, e.start, e.freq, r);
+        },
+        get: function (t, e) {
+          return t & (1 << e) - 1;
+        },
+        advanceSymbol: function (t, e, r, n) {
+          return function (t, e, r, n, i) {
+            if ((t = n * (t >> i) + (t & (1 << i) - 1) - r) < o.RANS_BYTE_L) do {
+              t = t << 8 | 255 & e.get();
+            } while (t < o.RANS_BYTE_L);
+            return t;
+          }(t, e, r.start, r.freq, n);
+        },
+        renormalize: function (t, e) {
+          if (t < o.RANS_BYTE_L) do {
+            t = t << 8 | 255 & e.get();
+          } while (t < o.RANS_BYTE_L);
+          return t;
+        }
+      };
+      t.exports = u;
+    }, function (t, e, r) {
+
+      t.exports = {
+        TF_SHIFT: 12,
+        TOTFREQ: 4096,
+        RANS_BYTE_L: 1 << 23
+      };
+    }, function (t, e, r) {
+      t.exports = r(322);
+    }, function (t, e, r) {
+      t.exports = r(330);
+    }, function (t, e, r) {
+      t.exports = r(347);
+    }, function (t, e) {
+      t.exports = function () {};
+    }, function (t, e, r) {
+      var n = r(13),
+          i = r(14),
+          o = n.document,
+          a = i(o) && i(o.createElement);
+
+      t.exports = function (t) {
+        return a ? o.createElement(t) : {};
+      };
+    }, function (t, e, r) {
+
+      var n = r(0),
+          i = r(172),
+          o = r(66),
+          a = r(86),
+          s = r(36),
+          u = r(20),
+          f = r(52),
+          c = r(6),
+          l = r(4),
+          h = r(35),
+          d = r(108),
+          p = d.IteratorPrototype,
+          g = d.BUGGY_SAFARI_ITERATORS,
+          v = c("iterator"),
+          y = function () {
+        return this;
+      };
+
+      t.exports = function (t, e, r, c, d, m, b) {
+        i(r, e, c);
+
+        var _,
+            w,
+            x,
+            E = function (t) {
+          if (t === d && T) return T;
+          if (!g && t in A) return A[t];
+
+          switch (t) {
+            case "keys":
+            case "values":
+            case "entries":
+              return function () {
+                return new r(this, t);
+              };
+          }
+
+          return function () {
+            return new r(this);
+          };
+        },
+            S = e + " Iterator",
+            k = !1,
+            A = t.prototype,
+            C = A[v] || A["@@iterator"] || d && A[d],
+            T = !g && C || E(d),
+            R = "Array" == e && A.entries || C;
+
+        if (R && (_ = o(R.call(new t())), p !== Object.prototype && _.next && (l || o(_) === p || (a ? a(_, p) : "function" != typeof _[v] && u(_, v, y)), s(_, S, !0, !0), l && (h[S] = y))), "values" == d && C && "values" !== C.name && (k = !0, T = function () {
+          return C.call(this);
+        }), l && !b || A[v] === T || u(A, v, T), h[e] = T, d) if (w = {
+          values: E("values"),
+          keys: m ? T : E("keys"),
+          entries: E("entries")
+        }, b) for (x in w) !g && !k && x in A || f(A, x, w[x]);else n({
+          target: e,
+          proto: !0,
+          forced: g || k
+        }, w);
+        return w;
+      };
+    }, function (t, e, r) {
+      var n = r(17),
+          i = r(65),
+          o = r(43),
+          a = r(28),
+          s = r(62),
+          u = r(24),
+          f = r(106),
+          c = Object.getOwnPropertyDescriptor;
+      e.f = n ? c : function (t, e) {
+        if (t = a(t), e = s(e, !0), f) try {
+          return c(t, e);
+        } catch (t) {}
+        if (u(t, e)) return o(!i.f.call(t, e), t[e]);
+      };
+    }, function (t, e, r) {
+      var n = r(28),
+          i = r(29),
+          o = r(84),
+          a = function (t) {
+        return function (e, r, a) {
+          var s,
+              u = n(e),
+              f = i(u.length),
+              c = o(a, f);
+
+          if (t && r != r) {
+            for (; f > c;) if ((s = u[c++]) != s) return !0;
+          } else for (; f > c; c++) if ((t || c in u) && u[c] === r) return t || c || 0;
+
+          return !t && -1;
+        };
+      };
+
+      t.exports = {
+        includes: a(!0),
+        indexOf: a(!1)
+      };
+    }, function (t, e) {
+      var r = Math.ceil,
+          n = Math.floor;
+
+      t.exports = function (t) {
+        return isNaN(t = +t) ? 0 : (t > 0 ? n : r)(t);
+      };
+    }, function (t, e, r) {
+      var n = r(83),
+          i = Math.max,
+          o = Math.min;
+
+      t.exports = function (t, e) {
+        var r = n(t);
+        return r < 0 ? i(r + e, 0) : o(r, e);
+      };
+    }, function (t, e) {
+      t.exports = ["constructor", "hasOwnProperty", "isPrototypeOf", "propertyIsEnumerable", "toLocaleString", "toString", "valueOf"];
+    }, function (t, e, r) {
+      var n = r(2),
+          i = r(175);
+      t.exports = Object.setPrototypeOf || ("__proto__" in {} ? function () {
+        var t,
+            e = !1,
+            r = {};
+
+        try {
+          (t = Object.getOwnPropertyDescriptor(Object.prototype, "__proto__").set).call(r, []), e = r instanceof Array;
+        } catch (t) {}
+
+        return function (r, o) {
+          return n(r), i(o), e ? t.call(r, o) : r.__proto__ = o, r;
+        };
+      }() : void 0);
+    }, function (t, e, r) {
+
+      var n = r(62),
+          i = r(21),
+          o = r(43);
+
+      t.exports = function (t, e, r) {
+        var a = n(e);
+        a in t ? i.f(t, a, o(0, r)) : t[a] = r;
+      };
+    }, function (t, e) {}, function (t, e) {
+      t.exports = function (t, e, r) {
+        if (!(t instanceof e)) throw TypeError("Incorrect " + (r ? r + " " : "") + "invocation");
+        return t;
+      };
+    }, function (t, e, r) {
+      var n = r(67),
+          i = r(35),
+          o = r(6)("iterator");
+
+      t.exports = function (t) {
+        if (null != t) return t[o] || t["@@iterator"] || i[n(t)];
+      };
+    }, function (t, e, r) {
+
+      var n,
+          i = "object" == typeof Reflect ? Reflect : null,
+          o = i && "function" == typeof i.apply ? i.apply : function (t, e, r) {
+        return Function.prototype.apply.call(t, e, r);
+      };
+      n = i && "function" == typeof i.ownKeys ? i.ownKeys : Object.getOwnPropertySymbols ? function (t) {
+        return Object.getOwnPropertyNames(t).concat(Object.getOwnPropertySymbols(t));
+      } : function (t) {
+        return Object.getOwnPropertyNames(t);
+      };
+
+      var a = Number.isNaN || function (t) {
+        return t != t;
+      };
+
+      function s() {
+        s.init.call(this);
+      }
+
+      t.exports = s, s.EventEmitter = s, s.prototype._events = void 0, s.prototype._eventsCount = 0, s.prototype._maxListeners = void 0;
+      var u = 10;
+
+      function f(t) {
+        return void 0 === t._maxListeners ? s.defaultMaxListeners : t._maxListeners;
+      }
+
+      function c(t, e, r, n) {
+        var i, o, a, s;
+        if ("function" != typeof r) throw new TypeError('The "listener" argument must be of type Function. Received type ' + typeof r);
+        if (void 0 === (o = t._events) ? (o = t._events = Object.create(null), t._eventsCount = 0) : (void 0 !== o.newListener && (t.emit("newListener", e, r.listener ? r.listener : r), o = t._events), a = o[e]), void 0 === a) a = o[e] = r, ++t._eventsCount;else if ("function" == typeof a ? a = o[e] = n ? [r, a] : [a, r] : n ? a.unshift(r) : a.push(r), (i = f(t)) > 0 && a.length > i && !a.warned) {
+          a.warned = !0;
+          var u = new Error("Possible EventEmitter memory leak detected. " + a.length + " " + String(e) + " listeners added. Use emitter.setMaxListeners() to increase limit");
+          u.name = "MaxListenersExceededWarning", u.emitter = t, u.type = e, u.count = a.length, s = u, console && console.warn && console.warn(s);
+        }
+        return t;
+      }
+
+      function l() {
+        for (var t = [], e = 0; e < arguments.length; e++) t.push(arguments[e]);
+
+        this.fired || (this.target.removeListener(this.type, this.wrapFn), this.fired = !0, o(this.listener, this.target, t));
+      }
+
+      function h(t, e, r) {
+        var n = {
+          fired: !1,
+          wrapFn: void 0,
+          target: t,
+          type: e,
+          listener: r
+        },
+            i = l.bind(n);
+        return i.listener = r, n.wrapFn = i, i;
+      }
+
+      function d(t, e, r) {
+        var n = t._events;
+        if (void 0 === n) return [];
+        var i = n[e];
+        return void 0 === i ? [] : "function" == typeof i ? r ? [i.listener || i] : [i] : r ? function (t) {
+          for (var e = new Array(t.length), r = 0; r < e.length; ++r) e[r] = t[r].listener || t[r];
+
+          return e;
+        }(i) : g(i, i.length);
+      }
+
+      function p(t) {
+        var e = this._events;
+
+        if (void 0 !== e) {
+          var r = e[t];
+          if ("function" == typeof r) return 1;
+          if (void 0 !== r) return r.length;
+        }
+
+        return 0;
+      }
+
+      function g(t, e) {
+        for (var r = new Array(e), n = 0; n < e; ++n) r[n] = t[n];
+
+        return r;
+      }
+
+      Object.defineProperty(s, "defaultMaxListeners", {
+        enumerable: !0,
+        get: function () {
+          return u;
+        },
+        set: function (t) {
+          if ("number" != typeof t || t < 0 || a(t)) throw new RangeError('The value of "defaultMaxListeners" is out of range. It must be a non-negative number. Received ' + t + ".");
+          u = t;
+        }
+      }), s.init = function () {
+        void 0 !== this._events && this._events !== Object.getPrototypeOf(this)._events || (this._events = Object.create(null), this._eventsCount = 0), this._maxListeners = this._maxListeners || void 0;
+      }, s.prototype.setMaxListeners = function (t) {
+        if ("number" != typeof t || t < 0 || a(t)) throw new RangeError('The value of "n" is out of range. It must be a non-negative number. Received ' + t + ".");
+        return this._maxListeners = t, this;
+      }, s.prototype.getMaxListeners = function () {
+        return f(this);
+      }, s.prototype.emit = function (t) {
+        for (var e = [], r = 1; r < arguments.length; r++) e.push(arguments[r]);
+
+        var n = "error" === t,
+            i = this._events;
+        if (void 0 !== i) n = n && void 0 === i.error;else if (!n) return !1;
+
+        if (n) {
+          var a;
+          if (e.length > 0 && (a = e[0]), a instanceof Error) throw a;
+          var s = new Error("Unhandled error." + (a ? " (" + a.message + ")" : ""));
+          throw s.context = a, s;
+        }
+
+        var u = i[t];
+        if (void 0 === u) return !1;
+        if ("function" == typeof u) o(u, this, e);else {
+          var f = u.length,
+              c = g(u, f);
+
+          for (r = 0; r < f; ++r) o(c[r], this, e);
+        }
+        return !0;
+      }, s.prototype.addListener = function (t, e) {
+        return c(this, t, e, !1);
+      }, s.prototype.on = s.prototype.addListener, s.prototype.prependListener = function (t, e) {
+        return c(this, t, e, !0);
+      }, s.prototype.once = function (t, e) {
+        if ("function" != typeof e) throw new TypeError('The "listener" argument must be of type Function. Received type ' + typeof e);
+        return this.on(t, h(this, t, e)), this;
+      }, s.prototype.prependOnceListener = function (t, e) {
+        if ("function" != typeof e) throw new TypeError('The "listener" argument must be of type Function. Received type ' + typeof e);
+        return this.prependListener(t, h(this, t, e)), this;
+      }, s.prototype.removeListener = function (t, e) {
+        var r, n, i, o, a;
+        if ("function" != typeof e) throw new TypeError('The "listener" argument must be of type Function. Received type ' + typeof e);
+        if (void 0 === (n = this._events)) return this;
+        if (void 0 === (r = n[t])) return this;
+        if (r === e || r.listener === e) 0 == --this._eventsCount ? this._events = Object.create(null) : (delete n[t], n.removeListener && this.emit("removeListener", t, r.listener || e));else if ("function" != typeof r) {
+          for (i = -1, o = r.length - 1; o >= 0; o--) if (r[o] === e || r[o].listener === e) {
+            a = r[o].listener, i = o;
+            break;
+          }
+
+          if (i < 0) return this;
+          0 === i ? r.shift() : function (t, e) {
+            for (; e + 1 < t.length; e++) t[e] = t[e + 1];
+
+            t.pop();
+          }(r, i), 1 === r.length && (n[t] = r[0]), void 0 !== n.removeListener && this.emit("removeListener", t, a || e);
+        }
+        return this;
+      }, s.prototype.off = s.prototype.removeListener, s.prototype.removeAllListeners = function (t) {
+        var e, r, n;
+        if (void 0 === (r = this._events)) return this;
+        if (void 0 === r.removeListener) return 0 === arguments.length ? (this._events = Object.create(null), this._eventsCount = 0) : void 0 !== r[t] && (0 == --this._eventsCount ? this._events = Object.create(null) : delete r[t]), this;
+
+        if (0 === arguments.length) {
+          var i,
+              o = Object.keys(r);
+
+          for (n = 0; n < o.length; ++n) "removeListener" !== (i = o[n]) && this.removeAllListeners(i);
+
+          return this.removeAllListeners("removeListener"), this._events = Object.create(null), this._eventsCount = 0, this;
+        }
+
+        if ("function" == typeof (e = r[t])) this.removeListener(t, e);else if (void 0 !== e) for (n = e.length - 1; n >= 0; n--) this.removeListener(t, e[n]);
+        return this;
+      }, s.prototype.listeners = function (t) {
+        return d(this, t, !0);
+      }, s.prototype.rawListeners = function (t) {
+        return d(this, t, !1);
+      }, s.listenerCount = function (t, e) {
+        return "function" == typeof t.listenerCount ? t.listenerCount(e) : p.call(t, e);
+      }, s.prototype.listenerCount = p, s.prototype.eventNames = function () {
+        return this._eventsCount > 0 ? n(this._events) : [];
+      };
+    }, function (t, e, r) {
+      (e = t.exports = r(127)).Stream = e, e.Readable = e, e.Writable = r(93), e.Duplex = r(39), e.Transform = r(131), e.PassThrough = r(207);
+    }, function (t, e, r) {
+
+      (function (e, n, i) {
+        var o = r(70);
+
+        function a(t) {
+          var e = this;
+          this.next = null, this.entry = null, this.finish = function () {
+            !function (t, e, r) {
+              var n = t.entry;
+              t.entry = null;
+
+              for (; n;) {
+                var i = n.callback;
+                e.pendingcb--, i(r), n = n.next;
+              }
+
+              e.corkedRequestsFree ? e.corkedRequestsFree.next = t : e.corkedRequestsFree = t;
+            }(e, t);
+          };
+        }
+
+        t.exports = m;
+        var s,
+            u = !e.browser && ["v0.10", "v0.9."].indexOf(e.version.slice(0, 5)) > -1 ? n : o.nextTick;
+        m.WritableState = y;
+        var f = r(57);
+        f.inherits = r(47);
+
+        var c = {
+          deprecate: r(206)
+        },
+            l = r(128),
+            h = r(71).Buffer,
+            d = i.Uint8Array || function () {};
+
+        var p,
+            g = r(129);
+
+        function v() {}
+
+        function y(t, e) {
+          s = s || r(39), t = t || {};
+          var n = e instanceof s;
+          this.objectMode = !!t.objectMode, n && (this.objectMode = this.objectMode || !!t.writableObjectMode);
+          var i = t.highWaterMark,
+              f = t.writableHighWaterMark,
+              c = this.objectMode ? 16 : 16384;
+          this.highWaterMark = i || 0 === i ? i : n && (f || 0 === f) ? f : c, this.highWaterMark = Math.floor(this.highWaterMark), this.finalCalled = !1, this.needDrain = !1, this.ending = !1, this.ended = !1, this.finished = !1, this.destroyed = !1;
+          var l = !1 === t.decodeStrings;
+          this.decodeStrings = !l, this.defaultEncoding = t.defaultEncoding || "utf8", this.length = 0, this.writing = !1, this.corked = 0, this.sync = !0, this.bufferProcessing = !1, this.onwrite = function (t) {
+            !function (t, e) {
+              var r = t._writableState,
+                  n = r.sync,
+                  i = r.writecb;
+              if (function (t) {
+                t.writing = !1, t.writecb = null, t.length -= t.writelen, t.writelen = 0;
+              }(r), e) !function (t, e, r, n, i) {
+                --e.pendingcb, r ? (o.nextTick(i, n), o.nextTick(S, t, e), t._writableState.errorEmitted = !0, t.emit("error", n)) : (i(n), t._writableState.errorEmitted = !0, t.emit("error", n), S(t, e));
+              }(t, r, n, e, i);else {
+                var a = x(r);
+                a || r.corked || r.bufferProcessing || !r.bufferedRequest || w(t, r), n ? u(_, t, r, a, i) : _(t, r, a, i);
+              }
+            }(e, t);
+          }, this.writecb = null, this.writelen = 0, this.bufferedRequest = null, this.lastBufferedRequest = null, this.pendingcb = 0, this.prefinished = !1, this.errorEmitted = !1, this.bufferedRequestCount = 0, this.corkedRequestsFree = new a(this);
+        }
+
+        function m(t) {
+          if (s = s || r(39), !(p.call(m, this) || this instanceof s)) return new m(t);
+          this._writableState = new y(t, this), this.writable = !0, t && ("function" == typeof t.write && (this._write = t.write), "function" == typeof t.writev && (this._writev = t.writev), "function" == typeof t.destroy && (this._destroy = t.destroy), "function" == typeof t.final && (this._final = t.final)), l.call(this);
+        }
+
+        function b(t, e, r, n, i, o, a) {
+          e.writelen = n, e.writecb = a, e.writing = !0, e.sync = !0, r ? t._writev(i, e.onwrite) : t._write(i, o, e.onwrite), e.sync = !1;
+        }
+
+        function _(t, e, r, n) {
+          r || function (t, e) {
+            0 === e.length && e.needDrain && (e.needDrain = !1, t.emit("drain"));
+          }(t, e), e.pendingcb--, n(), S(t, e);
+        }
+
+        function w(t, e) {
+          e.bufferProcessing = !0;
+          var r = e.bufferedRequest;
+
+          if (t._writev && r && r.next) {
+            var n = e.bufferedRequestCount,
+                i = new Array(n),
+                o = e.corkedRequestsFree;
+            o.entry = r;
+
+            for (var s = 0, u = !0; r;) i[s] = r, r.isBuf || (u = !1), r = r.next, s += 1;
+
+            i.allBuffers = u, b(t, e, !0, e.length, i, "", o.finish), e.pendingcb++, e.lastBufferedRequest = null, o.next ? (e.corkedRequestsFree = o.next, o.next = null) : e.corkedRequestsFree = new a(e), e.bufferedRequestCount = 0;
+          } else {
+            for (; r;) {
+              var f = r.chunk,
+                  c = r.encoding,
+                  l = r.callback;
+              if (b(t, e, !1, e.objectMode ? 1 : f.length, f, c, l), r = r.next, e.bufferedRequestCount--, e.writing) break;
+            }
+
+            null === r && (e.lastBufferedRequest = null);
+          }
+
+          e.bufferedRequest = r, e.bufferProcessing = !1;
+        }
+
+        function x(t) {
+          return t.ending && 0 === t.length && null === t.bufferedRequest && !t.finished && !t.writing;
+        }
+
+        function E(t, e) {
+          t._final(function (r) {
+            e.pendingcb--, r && t.emit("error", r), e.prefinished = !0, t.emit("prefinish"), S(t, e);
+          });
+        }
+
+        function S(t, e) {
+          var r = x(e);
+          return r && (!function (t, e) {
+            e.prefinished || e.finalCalled || ("function" == typeof t._final ? (e.pendingcb++, e.finalCalled = !0, o.nextTick(E, t, e)) : (e.prefinished = !0, t.emit("prefinish")));
+          }(t, e), 0 === e.pendingcb && (e.finished = !0, t.emit("finish"))), r;
+        }
+
+        f.inherits(m, l), y.prototype.getBuffer = function () {
+          for (var t = this.bufferedRequest, e = []; t;) e.push(t), t = t.next;
+
+          return e;
+        }, function () {
+          try {
+            Object.defineProperty(y.prototype, "buffer", {
+              get: c.deprecate(function () {
+                return this.getBuffer();
+              }, "_writableState.buffer is deprecated. Use _writableState.getBuffer instead.", "DEP0003")
+            });
+          } catch (t) {}
+        }(), "function" == typeof Symbol && Symbol.hasInstance && "function" == typeof Function.prototype[Symbol.hasInstance] ? (p = Function.prototype[Symbol.hasInstance], Object.defineProperty(m, Symbol.hasInstance, {
+          value: function (t) {
+            return !!p.call(this, t) || this === m && t && t._writableState instanceof y;
+          }
+        })) : p = function (t) {
+          return t instanceof this;
+        }, m.prototype.pipe = function () {
+          this.emit("error", new Error("Cannot pipe, not readable"));
+        }, m.prototype.write = function (t, e, r) {
+          var n,
+              i = this._writableState,
+              a = !1,
+              s = !i.objectMode && (n = t, h.isBuffer(n) || n instanceof d);
+          return s && !h.isBuffer(t) && (t = function (t) {
+            return h.from(t);
+          }(t)), "function" == typeof e && (r = e, e = null), s ? e = "buffer" : e || (e = i.defaultEncoding), "function" != typeof r && (r = v), i.ended ? function (t, e) {
+            var r = new Error("write after end");
+            t.emit("error", r), o.nextTick(e, r);
+          }(this, r) : (s || function (t, e, r, n) {
+            var i = !0,
+                a = !1;
+            return null === r ? a = new TypeError("May not write null values to stream") : "string" == typeof r || void 0 === r || e.objectMode || (a = new TypeError("Invalid non-string/buffer chunk")), a && (t.emit("error", a), o.nextTick(n, a), i = !1), i;
+          }(this, i, t, r)) && (i.pendingcb++, a = function (t, e, r, n, i, o) {
+            if (!r) {
+              var a = function (t, e, r) {
+                t.objectMode || !1 === t.decodeStrings || "string" != typeof e || (e = h.from(e, r));
+                return e;
+              }(e, n, i);
+
+              n !== a && (r = !0, i = "buffer", n = a);
+            }
+
+            var s = e.objectMode ? 1 : n.length;
+            e.length += s;
+            var u = e.length < e.highWaterMark;
+            u || (e.needDrain = !0);
+
+            if (e.writing || e.corked) {
+              var f = e.lastBufferedRequest;
+              e.lastBufferedRequest = {
+                chunk: n,
+                encoding: i,
+                isBuf: r,
+                callback: o,
+                next: null
+              }, f ? f.next = e.lastBufferedRequest : e.bufferedRequest = e.lastBufferedRequest, e.bufferedRequestCount += 1;
+            } else b(t, e, !1, s, n, i, o);
+
+            return u;
+          }(this, i, s, t, e, r)), a;
+        }, m.prototype.cork = function () {
+          this._writableState.corked++;
+        }, m.prototype.uncork = function () {
+          var t = this._writableState;
+          t.corked && (t.corked--, t.writing || t.corked || t.finished || t.bufferProcessing || !t.bufferedRequest || w(this, t));
+        }, m.prototype.setDefaultEncoding = function (t) {
+          if ("string" == typeof t && (t = t.toLowerCase()), !(["hex", "utf8", "utf-8", "ascii", "binary", "base64", "ucs2", "ucs-2", "utf16le", "utf-16le", "raw"].indexOf((t + "").toLowerCase()) > -1)) throw new TypeError("Unknown encoding: " + t);
+          return this._writableState.defaultEncoding = t, this;
+        }, Object.defineProperty(m.prototype, "writableHighWaterMark", {
+          enumerable: !1,
+          get: function () {
+            return this._writableState.highWaterMark;
+          }
+        }), m.prototype._write = function (t, e, r) {
+          r(new Error("_write() is not implemented"));
+        }, m.prototype._writev = null, m.prototype.end = function (t, e, r) {
+          var n = this._writableState;
+          "function" == typeof t ? (r = t, t = null, e = null) : "function" == typeof e && (r = e, e = null), null != t && this.write(t, e), n.corked && (n.corked = 1, this.uncork()), n.ending || n.finished || function (t, e, r) {
+            e.ending = !0, S(t, e), r && (e.finished ? o.nextTick(r) : t.once("finish", r));
+            e.ended = !0, t.writable = !1;
+          }(this, n, r);
+        }, Object.defineProperty(m.prototype, "destroyed", {
+          get: function () {
+            return void 0 !== this._writableState && this._writableState.destroyed;
+          },
+          set: function (t) {
+            this._writableState && (this._writableState.destroyed = t);
+          }
+        }), m.prototype.destroy = g.destroy, m.prototype._undestroy = g.undestroy, m.prototype._destroy = function (t, e) {
+          this.end(), e(t);
+        };
+      }).call(this, r(38), r(204).setImmediate, r(23));
+    }, function (t, e, r) {
+
+      t.exports = class {
+        constructor(t = {}) {
+          if (!(t.maxSize && t.maxSize > 0)) throw new TypeError("`maxSize` must be a number greater than 0");
+          this.maxSize = t.maxSize, this.cache = new Map(), this.oldCache = new Map(), this._size = 0;
+        }
+
+        _set(t, e) {
+          this.cache.set(t, e), this._size++, this._size >= this.maxSize && (this._size = 0, this.oldCache = this.cache, this.cache = new Map());
+        }
+
+        get(t) {
+          if (this.cache.has(t)) return this.cache.get(t);
+
+          if (this.oldCache.has(t)) {
+            const e = this.oldCache.get(t);
+            return this._set(t, e), e;
+          }
+        }
+
+        set(t, e) {
+          return this.cache.has(t) ? this.cache.set(t, e) : this._set(t, e), this;
+        }
+
+        has(t) {
+          return this.cache.has(t) || this.oldCache.has(t);
+        }
+
+        peek(t) {
+          return this.cache.has(t) ? this.cache.get(t) : this.oldCache.has(t) ? this.oldCache.get(t) : void 0;
+        }
+
+        delete(t) {
+          const e = this.cache.delete(t);
+          return e && this._size--, this.oldCache.delete(t) || e;
+        }
+
+        clear() {
+          this.cache.clear(), this.oldCache.clear(), this._size = 0;
+        }
+
+        *keys() {
+          for (const [t] of this) yield t;
+        }
+
+        *values() {
+          for (const [, t] of this) yield t;
+        }
+
+        *[Symbol.iterator]() {
+          for (const t of this.cache) yield t;
+
+          for (const t of this.oldCache) {
+            const [e] = t;
+            this.cache.has(e) || (yield t);
+          }
+        }
+
+        get size() {
+          let t = 0;
+
+          for (const e of this.oldCache.keys()) this.cache.has(e) || t++;
+
+          return this._size + t;
+        }
+
+      };
+    }, function (t, e, r) {
+      e.f = r(6);
+    }, function (t, e, r) {
+      var n = r(139);
+
+      function i(e, r) {
+        return t.exports = i = n || function (t, e) {
+          return t.__proto__ = e, t;
+        }, i(e, r);
+      }
+
+      t.exports = i;
+    }, function (t, e, r) {
+      t.exports = r(310);
+    }, function (t, e, r) {
+      t.exports = r(319);
+    }, function (t, e, r) {
+      t.exports = r(342);
+    }, function (t, e, r) {
+
+      t.exports = {
+        CRAM_FLAG_PRESERVE_QUAL_SCORES: 1,
+        CRAM_FLAG_DETACHED: 2,
+        CRAM_FLAG_MATE_DOWNSTREAM: 4,
+        CRAM_FLAG_NO_SEQ: 8,
+        CRAM_FLAG_MASK: 15,
+        CRAM_M_REVERSE: 1,
+        CRAM_M_UNMAP: 2,
+        BAM_FPAIRED: 1,
+        BAM_FPROPER_PAIR: 2,
+        BAM_FUNMAP: 4,
+        BAM_FMUNMAP: 8,
+        BAM_FREVERSE: 16,
+        BAM_FMREVERSE: 32,
+        BAM_FREAD1: 64,
+        BAM_FREAD2: 128,
+        BAM_FSECONDARY: 256,
+        BAM_FQCFAIL: 512,
+        BAM_FDUP: 1024,
+        BAM_FSUPPLEMENTARY: 2048,
+        BAM_CMATCH: 0,
+        BAM_CINS: 1,
+        BAM_CDEL: 2,
+        BAM_CREF_SKIP: 3,
+        BAM_CSOFT_CLIP: 4,
+        BAM_CHARD_CLIP: 5,
+        BAM_CPAD: 6,
+        BAM_CEQUAL: 7,
+        BAM_CDIFF: 8,
+        BAM_CBACK: 9,
+        BAM_CIGAR_STR: "MIDNSHP:XB",
+        BAM_CIGAR_SHIFT: 4,
+        BAM_CIGAR_MASK: 15,
+        BAM_CIGAR_TYPE: 246183
+      };
+    }, function (t, e, r) {
+      t.exports = r(368);
+    }, function (t, e, r) {
+      t.exports = r(396);
+    }, function (t, e, r) {
+      t.exports = r(399);
+    }, function (t, e, r) {
+
+      var n = r(164);
+      t.exports = n;
+    }, function (t, e) {
+      var r = {}.toString;
+
+      t.exports = Array.isArray || function (t) {
+        return "[object Array]" == r.call(t);
+      };
+    }, function (t, e, r) {
+      var n = r(17),
+          i = r(12),
+          o = r(79);
+      t.exports = !n && !i(function () {
+        return 7 != Object.defineProperty(o("div"), "a", {
+          get: function () {
+            return 7;
+          }
+        }).a;
+      });
+    }, function (t, e, r) {
+      var n = r(12),
+          i = /#|\.prototype\./,
+          o = function (t, e) {
+        var r = s[a(t)];
+        return r == f || r != u && ("function" == typeof e ? n(e) : !!e);
+      },
+          a = o.normalize = function (t) {
+        return String(t).replace(i, ".").toLowerCase();
+      },
+          s = o.data = {},
+          u = o.NATIVE = "N",
+          f = o.POLYFILL = "P";
+
+      t.exports = o;
+    }, function (t, e, r) {
+
+      var n,
+          i,
+          o,
+          a = r(66),
+          s = r(20),
+          u = r(24),
+          f = r(6),
+          c = r(4),
+          l = f("iterator"),
+          h = !1;
+      [].keys && ("next" in (o = [].keys()) ? (i = a(a(o))) !== Object.prototype && (n = i) : h = !0), null == n && (n = {}), c || u(n, l) || s(n, l, function () {
+        return this;
+      }), t.exports = {
+        IteratorPrototype: n,
+        BUGGY_SAFARI_ITERATORS: h
+      };
+    }, function (t, e, r) {
+      var n = r(12);
+      t.exports = !n(function () {
+        function t() {}
+
+        return t.prototype.constructor = null, Object.getPrototypeOf(new t()) !== t.prototype;
+      });
+    }, function (t, e, r) {
+      var n = r(12);
+      t.exports = !!Object.getOwnPropertySymbols && !n(function () {
+        return !String(Symbol());
+      });
+    }, function (t, e, r) {
+      var n = r(24),
+          i = r(28),
+          o = r(82).indexOf,
+          a = r(50);
+
+      t.exports = function (t, e) {
+        var r,
+            s = i(t),
+            u = 0,
+            f = [];
+
+        for (r in s) !n(a, r) && n(s, r) && f.push(r);
+
+        for (; e.length > u;) n(s, r = e[u++]) && (~o(f, r) || f.push(r));
+
+        return f;
+      };
+    }, function (t, e, r) {
+      var n = r(26);
+      t.exports = n("document", "documentElement");
+    }, function (t, e, r) {
+      var n = r(14),
+          i = r(53),
+          o = r(6)("species");
+
+      t.exports = function (t, e) {
+        var r;
+        return i(t) && ("function" != typeof (r = t.constructor) || r !== Array && !i(r.prototype) ? n(r) && null === (r = r[o]) && (r = void 0) : r = void 0), new (void 0 === r ? Array : r)(0 === e ? 0 : e);
+      };
+    }, function (t, e, r) {
+
+      var n = r(0),
+          i = r(12),
+          o = r(53),
+          a = r(14),
+          s = r(22),
+          u = r(29),
+          f = r(87),
+          c = r(113),
+          l = r(68),
+          h = r(6)("isConcatSpreadable"),
+          d = !i(function () {
+        var t = [];
+        return t[h] = !1, t.concat()[0] !== t;
+      }),
+          p = l("concat"),
+          g = function (t) {
+        if (!a(t)) return !1;
+        var e = t[h];
+        return void 0 !== e ? !!e : o(t);
+      };
+
+      n({
+        target: "Array",
+        proto: !0,
+        forced: !d || !p
+      }, {
+        concat: function (t) {
+          var e,
+              r,
+              n,
+              i,
+              o,
+              a = s(this),
+              l = c(a, 0),
+              h = 0;
+
+          for (e = -1, n = arguments.length; e < n; e++) if (o = -1 === e ? a : arguments[e], g(o)) {
+            if (h + (i = u(o.length)) > 9007199254740991) throw TypeError("Maximum allowed index exceeded");
+
+            for (r = 0; r < i; r++, h++) r in o && f(l, h, o[r]);
+          } else {
+            if (h >= 9007199254740991) throw TypeError("Maximum allowed index exceeded");
+            f(l, h++, o);
+          }
+
+          return l.length = h, l;
+        }
+      });
+    }, function (t, e, r) {
+      r(88), r(46), r(41), r(188), r(125), r(191);
+      var n = r(3);
+      t.exports = n.Promise;
+    }, function (t, e, r) {
+      var n = r(13);
+      t.exports = n.Promise;
+    }, function (t, e, r) {
+      var n = r(52);
+
+      t.exports = function (t, e, r) {
+        for (var i in e) r && r.unsafe && t[i] ? t[i] = e[i] : n(t, i, e[i], r);
+
+        return t;
+      };
+    }, function (t, e, r) {
+
+      var n = r(26),
+          i = r(21),
+          o = r(6),
+          a = r(17),
+          s = o("species");
+
+      t.exports = function (t) {
+        var e = n(t),
+            r = i.f;
+        a && e && !e[s] && r(e, s, {
+          configurable: !0,
+          get: function () {
+            return this;
+          }
+        });
+      };
+    }, function (t, e, r) {
+      var n = r(6),
+          i = r(35),
+          o = n("iterator"),
+          a = Array.prototype;
+
+      t.exports = function (t) {
+        return void 0 !== t && (i.Array === t || a[o] === t);
+      };
+    }, function (t, e, r) {
+      var n = r(2);
+
+      t.exports = function (t, e, r, i) {
+        try {
+          return i ? e(n(r)[0], r[1]) : e(r);
+        } catch (e) {
+          var o = t.return;
+          throw void 0 !== o && n(o.call(t)), e;
+        }
+      };
+    }, function (t, e, r) {
+      var n = r(6)("iterator"),
+          i = !1;
+
+      try {
+        var o = 0,
+            a = {
+          next: function () {
+            return {
+              done: !!o++
+            };
+          },
+          return: function () {
+            i = !0;
+          }
+        };
+        a[n] = function () {
+          return this;
+        }, Array.from(a, function () {
+          throw 2;
+        });
+      } catch (t) {}
+
+      t.exports = function (t, e) {
+        if (!e && !i) return !1;
+        var r = !1;
+
+        try {
+          var o = {};
+          o[n] = function () {
+            return {
+              next: function () {
+                return {
+                  done: r = !0
+                };
+              }
+            };
+          }, t(o);
+        } catch (t) {}
+
+        return r;
+      };
+    }, function (t, e, r) {
+      var n,
+          i,
+          o,
+          a = r(13),
+          s = r(12),
+          u = r(34),
+          f = r(15),
+          c = r(112),
+          l = r(79),
+          h = a.location,
+          d = a.setImmediate,
+          p = a.clearImmediate,
+          g = a.process,
+          v = a.MessageChannel,
+          y = a.Dispatch,
+          m = 0,
+          b = {},
+          _ = function (t) {
+        if (b.hasOwnProperty(t)) {
+          var e = b[t];
+          delete b[t], e();
+        }
+      },
+          w = function (t) {
+        return function () {
+          _(t);
+        };
+      },
+          x = function (t) {
+        _(t.data);
+      },
+          E = function (t) {
+        a.postMessage(t + "", h.protocol + "//" + h.host);
+      };
+
+      d && p || (d = function (t) {
+        for (var e = [], r = 1; arguments.length > r;) e.push(arguments[r++]);
+
+        return b[++m] = function () {
+          ("function" == typeof t ? t : Function(t)).apply(void 0, e);
+        }, n(m), m;
+      }, p = function (t) {
+        delete b[t];
+      }, "process" == u(g) ? n = function (t) {
+        g.nextTick(w(t));
+      } : y && y.now ? n = function (t) {
+        y.now(w(t));
+      } : v ? (o = (i = new v()).port2, i.port1.onmessage = x, n = f(o.postMessage, o, 1)) : !a.addEventListener || "function" != typeof postMessage || a.importScripts || s(E) ? n = "onreadystatechange" in l("script") ? function (t) {
+        c.appendChild(l("script")).onreadystatechange = function () {
+          c.removeChild(this), _(t);
+        };
+      } : function (t) {
+        setTimeout(w(t), 0);
+      } : (n = E, a.addEventListener("message", x, !1))), t.exports = {
+        set: d,
+        clear: p
+      };
+    }, function (t, e, r) {
+      var n = r(26);
+      t.exports = n("navigator", "userAgent") || "";
+    }, function (t, e, r) {
+      var n = r(2),
+          i = r(14),
+          o = r(56);
+
+      t.exports = function (t, e) {
+        if (n(t), i(e) && e.constructor === t) return e;
+        var r = o.f(t);
+        return (0, r.resolve)(e), r.promise;
+      };
+    }, function (t, e, r) {
+
+      var n = r(0),
+          i = r(5),
+          o = r(56),
+          a = r(69),
+          s = r(8);
+      n({
+        target: "Promise",
+        stat: !0
+      }, {
+        allSettled: function (t) {
+          var e = this,
+              r = o.f(e),
+              n = r.resolve,
+              u = r.reject,
+              f = a(function () {
+            var r = i(e.resolve),
+                o = [],
+                a = 0,
+                u = 1;
+            s(t, function (t) {
+              var i = a++,
+                  s = !1;
+              o.push(void 0), u++, r.call(e, t).then(function (t) {
+                s || (s = !0, o[i] = {
+                  status: "fulfilled",
+                  value: t
+                }, --u || n(o));
+              }, function (t) {
+                s || (s = !0, o[i] = {
+                  status: "rejected",
+                  reason: t
+                }, --u || n(o));
+              });
+            }), --u || n(o);
+          });
+          return f.error && u(f.value), r.promise;
+        }
+      });
+    }, function (t, e, r) {
+
+      (function (t) {
+        var n = r(19).Buffer,
+            i = r(200).Transform,
+            o = r(212),
+            a = r(133),
+            s = r(132).ok,
+            u = r(19).kMaxLength,
+            f = "Cannot create final Buffer. It would be larger than 0x" + u.toString(16) + " bytes";
+        o.Z_MIN_WINDOWBITS = 8, o.Z_MAX_WINDOWBITS = 15, o.Z_DEFAULT_WINDOWBITS = 15, o.Z_MIN_CHUNK = 64, o.Z_MAX_CHUNK = 1 / 0, o.Z_DEFAULT_CHUNK = 16384, o.Z_MIN_MEMLEVEL = 1, o.Z_MAX_MEMLEVEL = 9, o.Z_DEFAULT_MEMLEVEL = 8, o.Z_MIN_LEVEL = -1, o.Z_MAX_LEVEL = 9, o.Z_DEFAULT_LEVEL = o.Z_DEFAULT_COMPRESSION;
+
+        for (var c = Object.keys(o), l = 0; l < c.length; l++) {
+          var h = c[l];
+          h.match(/^Z/) && Object.defineProperty(e, h, {
+            enumerable: !0,
+            value: o[h],
+            writable: !1
+          });
+        }
+
+        for (var d = {
+          Z_OK: o.Z_OK,
+          Z_STREAM_END: o.Z_STREAM_END,
+          Z_NEED_DICT: o.Z_NEED_DICT,
+          Z_ERRNO: o.Z_ERRNO,
+          Z_STREAM_ERROR: o.Z_STREAM_ERROR,
+          Z_DATA_ERROR: o.Z_DATA_ERROR,
+          Z_MEM_ERROR: o.Z_MEM_ERROR,
+          Z_BUF_ERROR: o.Z_BUF_ERROR,
+          Z_VERSION_ERROR: o.Z_VERSION_ERROR
+        }, p = Object.keys(d), g = 0; g < p.length; g++) {
+          var v = p[g];
+          d[d[v]] = v;
+        }
+
+        function y(t, e, r) {
+          var i = [],
+              o = 0;
+
+          function a() {
+            for (var e; null !== (e = t.read());) i.push(e), o += e.length;
+
+            t.once("readable", a);
+          }
+
+          function s() {
+            var e,
+                a = null;
+            o >= u ? a = new RangeError(f) : e = n.concat(i, o), i = [], t.close(), r(a, e);
+          }
+
+          t.on("error", function (e) {
+            t.removeListener("end", s), t.removeListener("readable", a), r(e);
+          }), t.on("end", s), t.end(e), a();
+        }
+
+        function m(t, e) {
+          if ("string" == typeof e && (e = n.from(e)), !n.isBuffer(e)) throw new TypeError("Not a string or buffer");
+          var r = t._finishFlushFlag;
+          return t._processChunk(e, r);
+        }
+
+        function b(t) {
+          if (!(this instanceof b)) return new b(t);
+          C.call(this, t, o.DEFLATE);
+        }
+
+        function _(t) {
+          if (!(this instanceof _)) return new _(t);
+          C.call(this, t, o.INFLATE);
+        }
+
+        function w(t) {
+          if (!(this instanceof w)) return new w(t);
+          C.call(this, t, o.GZIP);
+        }
+
+        function x(t) {
+          if (!(this instanceof x)) return new x(t);
+          C.call(this, t, o.GUNZIP);
+        }
+
+        function E(t) {
+          if (!(this instanceof E)) return new E(t);
+          C.call(this, t, o.DEFLATERAW);
+        }
+
+        function S(t) {
+          if (!(this instanceof S)) return new S(t);
+          C.call(this, t, o.INFLATERAW);
+        }
+
+        function k(t) {
+          if (!(this instanceof k)) return new k(t);
+          C.call(this, t, o.UNZIP);
+        }
+
+        function A(t) {
+          return t === o.Z_NO_FLUSH || t === o.Z_PARTIAL_FLUSH || t === o.Z_SYNC_FLUSH || t === o.Z_FULL_FLUSH || t === o.Z_FINISH || t === o.Z_BLOCK;
+        }
+
+        function C(t, r) {
+          var a = this;
+          if (this._opts = t = t || {}, this._chunkSize = t.chunkSize || e.Z_DEFAULT_CHUNK, i.call(this, t), t.flush && !A(t.flush)) throw new Error("Invalid flush flag: " + t.flush);
+          if (t.finishFlush && !A(t.finishFlush)) throw new Error("Invalid flush flag: " + t.finishFlush);
+          if (this._flushFlag = t.flush || o.Z_NO_FLUSH, this._finishFlushFlag = void 0 !== t.finishFlush ? t.finishFlush : o.Z_FINISH, t.chunkSize && (t.chunkSize < e.Z_MIN_CHUNK || t.chunkSize > e.Z_MAX_CHUNK)) throw new Error("Invalid chunk size: " + t.chunkSize);
+          if (t.windowBits && (t.windowBits < e.Z_MIN_WINDOWBITS || t.windowBits > e.Z_MAX_WINDOWBITS)) throw new Error("Invalid windowBits: " + t.windowBits);
+          if (t.level && (t.level < e.Z_MIN_LEVEL || t.level > e.Z_MAX_LEVEL)) throw new Error("Invalid compression level: " + t.level);
+          if (t.memLevel && (t.memLevel < e.Z_MIN_MEMLEVEL || t.memLevel > e.Z_MAX_MEMLEVEL)) throw new Error("Invalid memLevel: " + t.memLevel);
+          if (t.strategy && t.strategy != e.Z_FILTERED && t.strategy != e.Z_HUFFMAN_ONLY && t.strategy != e.Z_RLE && t.strategy != e.Z_FIXED && t.strategy != e.Z_DEFAULT_STRATEGY) throw new Error("Invalid strategy: " + t.strategy);
+          if (t.dictionary && !n.isBuffer(t.dictionary)) throw new Error("Invalid dictionary: it should be a Buffer instance");
+          this._handle = new o.Zlib(r);
+          var s = this;
+          this._hadError = !1, this._handle.onerror = function (t, r) {
+            T(s), s._hadError = !0;
+            var n = new Error(t);
+            n.errno = r, n.code = e.codes[r], s.emit("error", n);
+          };
+          var u = e.Z_DEFAULT_COMPRESSION;
+          "number" == typeof t.level && (u = t.level);
+          var f = e.Z_DEFAULT_STRATEGY;
+          "number" == typeof t.strategy && (f = t.strategy), this._handle.init(t.windowBits || e.Z_DEFAULT_WINDOWBITS, u, t.memLevel || e.Z_DEFAULT_MEMLEVEL, f, t.dictionary), this._buffer = n.allocUnsafe(this._chunkSize), this._offset = 0, this._level = u, this._strategy = f, this.once("end", this.close), Object.defineProperty(this, "_closed", {
+            get: function () {
+              return !a._handle;
+            },
+            configurable: !0,
+            enumerable: !0
+          });
+        }
+
+        function T(e, r) {
+          r && t.nextTick(r), e._handle && (e._handle.close(), e._handle = null);
+        }
+
+        function R(t) {
+          t.emit("close");
+        }
+
+        Object.defineProperty(e, "codes", {
+          enumerable: !0,
+          value: Object.freeze(d),
+          writable: !1
+        }), e.Deflate = b, e.Inflate = _, e.Gzip = w, e.Gunzip = x, e.DeflateRaw = E, e.InflateRaw = S, e.Unzip = k, e.createDeflate = function (t) {
+          return new b(t);
+        }, e.createInflate = function (t) {
+          return new _(t);
+        }, e.createDeflateRaw = function (t) {
+          return new E(t);
+        }, e.createInflateRaw = function (t) {
+          return new S(t);
+        }, e.createGzip = function (t) {
+          return new w(t);
+        }, e.createGunzip = function (t) {
+          return new x(t);
+        }, e.createUnzip = function (t) {
+          return new k(t);
+        }, e.deflate = function (t, e, r) {
+          return "function" == typeof e && (r = e, e = {}), y(new b(e), t, r);
+        }, e.deflateSync = function (t, e) {
+          return m(new b(e), t);
+        }, e.gzip = function (t, e, r) {
+          return "function" == typeof e && (r = e, e = {}), y(new w(e), t, r);
+        }, e.gzipSync = function (t, e) {
+          return m(new w(e), t);
+        }, e.deflateRaw = function (t, e, r) {
+          return "function" == typeof e && (r = e, e = {}), y(new E(e), t, r);
+        }, e.deflateRawSync = function (t, e) {
+          return m(new E(e), t);
+        }, e.unzip = function (t, e, r) {
+          return "function" == typeof e && (r = e, e = {}), y(new k(e), t, r);
+        }, e.unzipSync = function (t, e) {
+          return m(new k(e), t);
+        }, e.inflate = function (t, e, r) {
+          return "function" == typeof e && (r = e, e = {}), y(new _(e), t, r);
+        }, e.inflateSync = function (t, e) {
+          return m(new _(e), t);
+        }, e.gunzip = function (t, e, r) {
+          return "function" == typeof e && (r = e, e = {}), y(new x(e), t, r);
+        }, e.gunzipSync = function (t, e) {
+          return m(new x(e), t);
+        }, e.inflateRaw = function (t, e, r) {
+          return "function" == typeof e && (r = e, e = {}), y(new S(e), t, r);
+        }, e.inflateRawSync = function (t, e) {
+          return m(new S(e), t);
+        }, a.inherits(C, i), C.prototype.params = function (r, n, i) {
+          if (r < e.Z_MIN_LEVEL || r > e.Z_MAX_LEVEL) throw new RangeError("Invalid compression level: " + r);
+          if (n != e.Z_FILTERED && n != e.Z_HUFFMAN_ONLY && n != e.Z_RLE && n != e.Z_FIXED && n != e.Z_DEFAULT_STRATEGY) throw new TypeError("Invalid strategy: " + n);
+
+          if (this._level !== r || this._strategy !== n) {
+            var a = this;
+            this.flush(o.Z_SYNC_FLUSH, function () {
+              s(a._handle, "zlib binding closed"), a._handle.params(r, n), a._hadError || (a._level = r, a._strategy = n, i && i());
+            });
+          } else t.nextTick(i);
+        }, C.prototype.reset = function () {
+          return s(this._handle, "zlib binding closed"), this._handle.reset();
+        }, C.prototype._flush = function (t) {
+          this._transform(n.alloc(0), "", t);
+        }, C.prototype.flush = function (e, r) {
+          var i = this,
+              a = this._writableState;
+          ("function" == typeof e || void 0 === e && !r) && (r = e, e = o.Z_FULL_FLUSH), a.ended ? r && t.nextTick(r) : a.ending ? r && this.once("end", r) : a.needDrain ? r && this.once("drain", function () {
+            return i.flush(e, r);
+          }) : (this._flushFlag = e, this.write(n.alloc(0), "", r));
+        }, C.prototype.close = function (e) {
+          T(this, e), t.nextTick(R, this);
+        }, C.prototype._transform = function (t, e, r) {
+          var i,
+              a = this._writableState,
+              s = (a.ending || a.ended) && (!t || a.length === t.length);
+          return null === t || n.isBuffer(t) ? this._handle ? (s ? i = this._finishFlushFlag : (i = this._flushFlag, t.length >= a.length && (this._flushFlag = this._opts.flush || o.Z_NO_FLUSH)), void this._processChunk(t, i, r)) : r(new Error("zlib binding closed")) : r(new Error("invalid input"));
+        }, C.prototype._processChunk = function (t, e, r) {
+          var i = t && t.length,
+              o = this._chunkSize - this._offset,
+              a = 0,
+              c = this,
+              l = "function" == typeof r;
+
+          if (!l) {
+            var h,
+                d = [],
+                p = 0;
+            this.on("error", function (t) {
+              h = t;
+            }), s(this._handle, "zlib binding closed");
+
+            do {
+              var g = this._handle.writeSync(e, t, a, i, this._buffer, this._offset, o);
+            } while (!this._hadError && m(g[0], g[1]));
+
+            if (this._hadError) throw h;
+            if (p >= u) throw T(this), new RangeError(f);
+            var v = n.concat(d, p);
+            return T(this), v;
+          }
+
+          s(this._handle, "zlib binding closed");
+
+          var y = this._handle.write(e, t, a, i, this._buffer, this._offset, o);
+
+          function m(u, f) {
+            if (this && (this.buffer = null, this.callback = null), !c._hadError) {
+              var h = o - f;
+
+              if (s(h >= 0, "have should not go down"), h > 0) {
+                var g = c._buffer.slice(c._offset, c._offset + h);
+
+                c._offset += h, l ? c.push(g) : (d.push(g), p += g.length);
+              }
+
+              if ((0 === f || c._offset >= c._chunkSize) && (o = c._chunkSize, c._offset = 0, c._buffer = n.allocUnsafe(c._chunkSize)), 0 === f) {
+                if (a += i - u, i = u, !l) return !0;
+
+                var v = c._handle.write(e, t, a, i, c._buffer, c._offset, c._chunkSize);
+
+                return v.callback = m, void (v.buffer = t);
+              }
+
+              if (!l) return !1;
+              r();
+            }
+          }
+
+          y.buffer = t, y.callback = m;
+        }, a.inherits(b, C), a.inherits(_, C), a.inherits(w, C), a.inherits(x, C), a.inherits(E, C), a.inherits(S, C), a.inherits(k, C);
+      }).call(this, r(38));
+    }, function (t, e, r) {
+
+      (function (e, n) {
+        var i = r(70);
+        t.exports = b;
+        var o,
+            a = r(105);
+        b.ReadableState = m;
+        r(91).EventEmitter;
+
+        var s = function (t, e) {
+          return t.listeners(e).length;
+        },
+            u = r(128),
+            f = r(71).Buffer,
+            c = e.Uint8Array || function () {};
+
+        var l = r(57);
+        l.inherits = r(47);
+        var h = r(201),
+            d = void 0;
+        d = h && h.debuglog ? h.debuglog("stream") : function () {};
+        var p,
+            g = r(202),
+            v = r(129);
+        l.inherits(b, u);
+        var y = ["error", "close", "destroy", "pause", "resume"];
+
+        function m(t, e) {
+          t = t || {};
+          var n = e instanceof (o = o || r(39));
+          this.objectMode = !!t.objectMode, n && (this.objectMode = this.objectMode || !!t.readableObjectMode);
+          var i = t.highWaterMark,
+              a = t.readableHighWaterMark,
+              s = this.objectMode ? 16 : 16384;
+          this.highWaterMark = i || 0 === i ? i : n && (a || 0 === a) ? a : s, this.highWaterMark = Math.floor(this.highWaterMark), this.buffer = new g(), this.length = 0, this.pipes = null, this.pipesCount = 0, this.flowing = null, this.ended = !1, this.endEmitted = !1, this.reading = !1, this.sync = !0, this.needReadable = !1, this.emittedReadable = !1, this.readableListening = !1, this.resumeScheduled = !1, this.destroyed = !1, this.defaultEncoding = t.defaultEncoding || "utf8", this.awaitDrain = 0, this.readingMore = !1, this.decoder = null, this.encoding = null, t.encoding && (p || (p = r(130).StringDecoder), this.decoder = new p(t.encoding), this.encoding = t.encoding);
+        }
+
+        function b(t) {
+          if (o = o || r(39), !(this instanceof b)) return new b(t);
+          this._readableState = new m(t, this), this.readable = !0, t && ("function" == typeof t.read && (this._read = t.read), "function" == typeof t.destroy && (this._destroy = t.destroy)), u.call(this);
+        }
+
+        function _(t, e, r, n, i) {
+          var o,
+              a = t._readableState;
+          null === e ? (a.reading = !1, function (t, e) {
+            if (e.ended) return;
+
+            if (e.decoder) {
+              var r = e.decoder.end();
+              r && r.length && (e.buffer.push(r), e.length += e.objectMode ? 1 : r.length);
+            }
+
+            e.ended = !0, S(t);
+          }(t, a)) : (i || (o = function (t, e) {
+            var r;
+            n = e, f.isBuffer(n) || n instanceof c || "string" == typeof e || void 0 === e || t.objectMode || (r = new TypeError("Invalid non-string/buffer chunk"));
+            var n;
+            return r;
+          }(a, e)), o ? t.emit("error", o) : a.objectMode || e && e.length > 0 ? ("string" == typeof e || a.objectMode || Object.getPrototypeOf(e) === f.prototype || (e = function (t) {
+            return f.from(t);
+          }(e)), n ? a.endEmitted ? t.emit("error", new Error("stream.unshift() after end event")) : w(t, a, e, !0) : a.ended ? t.emit("error", new Error("stream.push() after EOF")) : (a.reading = !1, a.decoder && !r ? (e = a.decoder.write(e), a.objectMode || 0 !== e.length ? w(t, a, e, !1) : A(t, a)) : w(t, a, e, !1))) : n || (a.reading = !1));
+          return function (t) {
+            return !t.ended && (t.needReadable || t.length < t.highWaterMark || 0 === t.length);
+          }(a);
+        }
+
+        function w(t, e, r, n) {
+          e.flowing && 0 === e.length && !e.sync ? (t.emit("data", r), t.read(0)) : (e.length += e.objectMode ? 1 : r.length, n ? e.buffer.unshift(r) : e.buffer.push(r), e.needReadable && S(t)), A(t, e);
+        }
+
+        Object.defineProperty(b.prototype, "destroyed", {
+          get: function () {
+            return void 0 !== this._readableState && this._readableState.destroyed;
+          },
+          set: function (t) {
+            this._readableState && (this._readableState.destroyed = t);
+          }
+        }), b.prototype.destroy = v.destroy, b.prototype._undestroy = v.undestroy, b.prototype._destroy = function (t, e) {
+          this.push(null), e(t);
+        }, b.prototype.push = function (t, e) {
+          var r,
+              n = this._readableState;
+          return n.objectMode ? r = !0 : "string" == typeof t && ((e = e || n.defaultEncoding) !== n.encoding && (t = f.from(t, e), e = ""), r = !0), _(this, t, e, !1, r);
+        }, b.prototype.unshift = function (t) {
+          return _(this, t, null, !0, !1);
+        }, b.prototype.isPaused = function () {
+          return !1 === this._readableState.flowing;
+        }, b.prototype.setEncoding = function (t) {
+          return p || (p = r(130).StringDecoder), this._readableState.decoder = new p(t), this._readableState.encoding = t, this;
+        };
+        var x = 8388608;
+
+        function E(t, e) {
+          return t <= 0 || 0 === e.length && e.ended ? 0 : e.objectMode ? 1 : t != t ? e.flowing && e.length ? e.buffer.head.data.length : e.length : (t > e.highWaterMark && (e.highWaterMark = function (t) {
+            return t >= x ? t = x : (t--, t |= t >>> 1, t |= t >>> 2, t |= t >>> 4, t |= t >>> 8, t |= t >>> 16, t++), t;
+          }(t)), t <= e.length ? t : e.ended ? e.length : (e.needReadable = !0, 0));
+        }
+
+        function S(t) {
+          var e = t._readableState;
+          e.needReadable = !1, e.emittedReadable || (d("emitReadable", e.flowing), e.emittedReadable = !0, e.sync ? i.nextTick(k, t) : k(t));
+        }
+
+        function k(t) {
+          d("emit readable"), t.emit("readable"), O(t);
+        }
+
+        function A(t, e) {
+          e.readingMore || (e.readingMore = !0, i.nextTick(C, t, e));
+        }
+
+        function C(t, e) {
+          for (var r = e.length; !e.reading && !e.flowing && !e.ended && e.length < e.highWaterMark && (d("maybeReadMore read 0"), t.read(0), r !== e.length);) r = e.length;
+
+          e.readingMore = !1;
+        }
+
+        function T(t) {
+          d("readable nexttick read 0"), t.read(0);
+        }
+
+        function R(t, e) {
+          e.reading || (d("resume read 0"), t.read(0)), e.resumeScheduled = !1, e.awaitDrain = 0, t.emit("resume"), O(t), e.flowing && !e.reading && t.read(0);
+        }
+
+        function O(t) {
+          var e = t._readableState;
+
+          for (d("flow", e.flowing); e.flowing && null !== t.read(););
+        }
+
+        function I(t, e) {
+          return 0 === e.length ? null : (e.objectMode ? r = e.buffer.shift() : !t || t >= e.length ? (r = e.decoder ? e.buffer.join("") : 1 === e.buffer.length ? e.buffer.head.data : e.buffer.concat(e.length), e.buffer.clear()) : r = function (t, e, r) {
+            var n;
+            t < e.head.data.length ? (n = e.head.data.slice(0, t), e.head.data = e.head.data.slice(t)) : n = t === e.head.data.length ? e.shift() : r ? function (t, e) {
+              var r = e.head,
+                  n = 1,
+                  i = r.data;
+              t -= i.length;
+
+              for (; r = r.next;) {
+                var o = r.data,
+                    a = t > o.length ? o.length : t;
+
+                if (a === o.length ? i += o : i += o.slice(0, t), 0 === (t -= a)) {
+                  a === o.length ? (++n, r.next ? e.head = r.next : e.head = e.tail = null) : (e.head = r, r.data = o.slice(a));
+                  break;
+                }
+
+                ++n;
+              }
+
+              return e.length -= n, i;
+            }(t, e) : function (t, e) {
+              var r = f.allocUnsafe(t),
+                  n = e.head,
+                  i = 1;
+              n.data.copy(r), t -= n.data.length;
+
+              for (; n = n.next;) {
+                var o = n.data,
+                    a = t > o.length ? o.length : t;
+
+                if (o.copy(r, r.length - t, 0, a), 0 === (t -= a)) {
+                  a === o.length ? (++i, n.next ? e.head = n.next : e.head = e.tail = null) : (e.head = n, n.data = o.slice(a));
+                  break;
+                }
+
+                ++i;
+              }
+
+              return e.length -= i, r;
+            }(t, e);
+            return n;
+          }(t, e.buffer, e.decoder), r);
+          var r;
+        }
+
+        function L(t) {
+          var e = t._readableState;
+          if (e.length > 0) throw new Error('"endReadable()" called on non-empty stream');
+          e.endEmitted || (e.ended = !0, i.nextTick(B, e, t));
+        }
+
+        function B(t, e) {
+          t.endEmitted || 0 !== t.length || (t.endEmitted = !0, e.readable = !1, e.emit("end"));
+        }
+
+        function P(t, e) {
+          for (var r = 0, n = t.length; r < n; r++) if (t[r] === e) return r;
+
+          return -1;
+        }
+
+        b.prototype.read = function (t) {
+          d("read", t), t = parseInt(t, 10);
+          var e = this._readableState,
+              r = t;
+          if (0 !== t && (e.emittedReadable = !1), 0 === t && e.needReadable && (e.length >= e.highWaterMark || e.ended)) return d("read: emitReadable", e.length, e.ended), 0 === e.length && e.ended ? L(this) : S(this), null;
+          if (0 === (t = E(t, e)) && e.ended) return 0 === e.length && L(this), null;
+          var n,
+              i = e.needReadable;
+          return d("need readable", i), (0 === e.length || e.length - t < e.highWaterMark) && d("length less than watermark", i = !0), e.ended || e.reading ? d("reading or ended", i = !1) : i && (d("do read"), e.reading = !0, e.sync = !0, 0 === e.length && (e.needReadable = !0), this._read(e.highWaterMark), e.sync = !1, e.reading || (t = E(r, e))), null === (n = t > 0 ? I(t, e) : null) ? (e.needReadable = !0, t = 0) : e.length -= t, 0 === e.length && (e.ended || (e.needReadable = !0), r !== t && e.ended && L(this)), null !== n && this.emit("data", n), n;
+        }, b.prototype._read = function (t) {
+          this.emit("error", new Error("_read() is not implemented"));
+        }, b.prototype.pipe = function (t, e) {
+          var r = this,
+              o = this._readableState;
+
+          switch (o.pipesCount) {
+            case 0:
+              o.pipes = t;
+              break;
+
+            case 1:
+              o.pipes = [o.pipes, t];
+              break;
+
+            default:
+              o.pipes.push(t);
+          }
+
+          o.pipesCount += 1, d("pipe count=%d opts=%j", o.pipesCount, e);
+          var u = (!e || !1 !== e.end) && t !== n.stdout && t !== n.stderr ? c : b;
+
+          function f(e, n) {
+            d("onunpipe"), e === r && n && !1 === n.hasUnpiped && (n.hasUnpiped = !0, d("cleanup"), t.removeListener("close", y), t.removeListener("finish", m), t.removeListener("drain", l), t.removeListener("error", v), t.removeListener("unpipe", f), r.removeListener("end", c), r.removeListener("end", b), r.removeListener("data", g), h = !0, !o.awaitDrain || t._writableState && !t._writableState.needDrain || l());
+          }
+
+          function c() {
+            d("onend"), t.end();
+          }
+
+          o.endEmitted ? i.nextTick(u) : r.once("end", u), t.on("unpipe", f);
+
+          var l = function (t) {
+            return function () {
+              var e = t._readableState;
+              d("pipeOnDrain", e.awaitDrain), e.awaitDrain && e.awaitDrain--, 0 === e.awaitDrain && s(t, "data") && (e.flowing = !0, O(t));
+            };
+          }(r);
+
+          t.on("drain", l);
+          var h = !1;
+          var p = !1;
+
+          function g(e) {
+            d("ondata"), p = !1, !1 !== t.write(e) || p || ((1 === o.pipesCount && o.pipes === t || o.pipesCount > 1 && -1 !== P(o.pipes, t)) && !h && (d("false write response, pause", r._readableState.awaitDrain), r._readableState.awaitDrain++, p = !0), r.pause());
+          }
+
+          function v(e) {
+            d("onerror", e), b(), t.removeListener("error", v), 0 === s(t, "error") && t.emit("error", e);
+          }
+
+          function y() {
+            t.removeListener("finish", m), b();
+          }
+
+          function m() {
+            d("onfinish"), t.removeListener("close", y), b();
+          }
+
+          function b() {
+            d("unpipe"), r.unpipe(t);
+          }
+
+          return r.on("data", g), function (t, e, r) {
+            if ("function" == typeof t.prependListener) return t.prependListener(e, r);
+            t._events && t._events[e] ? a(t._events[e]) ? t._events[e].unshift(r) : t._events[e] = [r, t._events[e]] : t.on(e, r);
+          }(t, "error", v), t.once("close", y), t.once("finish", m), t.emit("pipe", r), o.flowing || (d("pipe resume"), r.resume()), t;
+        }, b.prototype.unpipe = function (t) {
+          var e = this._readableState,
+              r = {
+            hasUnpiped: !1
+          };
+          if (0 === e.pipesCount) return this;
+          if (1 === e.pipesCount) return t && t !== e.pipes ? this : (t || (t = e.pipes), e.pipes = null, e.pipesCount = 0, e.flowing = !1, t && t.emit("unpipe", this, r), this);
+
+          if (!t) {
+            var n = e.pipes,
+                i = e.pipesCount;
+            e.pipes = null, e.pipesCount = 0, e.flowing = !1;
+
+            for (var o = 0; o < i; o++) n[o].emit("unpipe", this, r);
+
+            return this;
+          }
+
+          var a = P(e.pipes, t);
+          return -1 === a ? this : (e.pipes.splice(a, 1), e.pipesCount -= 1, 1 === e.pipesCount && (e.pipes = e.pipes[0]), t.emit("unpipe", this, r), this);
+        }, b.prototype.on = function (t, e) {
+          var r = u.prototype.on.call(this, t, e);
+          if ("data" === t) !1 !== this._readableState.flowing && this.resume();else if ("readable" === t) {
+            var n = this._readableState;
+            n.endEmitted || n.readableListening || (n.readableListening = n.needReadable = !0, n.emittedReadable = !1, n.reading ? n.length && S(this) : i.nextTick(T, this));
+          }
+          return r;
+        }, b.prototype.addListener = b.prototype.on, b.prototype.resume = function () {
+          var t = this._readableState;
+          return t.flowing || (d("resume"), t.flowing = !0, function (t, e) {
+            e.resumeScheduled || (e.resumeScheduled = !0, i.nextTick(R, t, e));
+          }(this, t)), this;
+        }, b.prototype.pause = function () {
+          return d("call pause flowing=%j", this._readableState.flowing), !1 !== this._readableState.flowing && (d("pause"), this._readableState.flowing = !1, this.emit("pause")), this;
+        }, b.prototype.wrap = function (t) {
+          var e = this,
+              r = this._readableState,
+              n = !1;
+
+          for (var i in t.on("end", function () {
+            if (d("wrapped end"), r.decoder && !r.ended) {
+              var t = r.decoder.end();
+              t && t.length && e.push(t);
+            }
+
+            e.push(null);
+          }), t.on("data", function (i) {
+            (d("wrapped data"), r.decoder && (i = r.decoder.write(i)), r.objectMode && null == i) || (r.objectMode || i && i.length) && (e.push(i) || (n = !0, t.pause()));
+          }), t) void 0 === this[i] && "function" == typeof t[i] && (this[i] = function (e) {
+            return function () {
+              return t[e].apply(t, arguments);
+            };
+          }(i));
+
+          for (var o = 0; o < y.length; o++) t.on(y[o], this.emit.bind(this, y[o]));
+
+          return this._read = function (e) {
+            d("wrapped _read", e), n && (n = !1, t.resume());
+          }, this;
+        }, Object.defineProperty(b.prototype, "readableHighWaterMark", {
+          enumerable: !1,
+          get: function () {
+            return this._readableState.highWaterMark;
+          }
+        }), b._fromList = I;
+      }).call(this, r(23), r(38));
+    }, function (t, e, r) {
+      t.exports = r(91).EventEmitter;
+    }, function (t, e, r) {
+
+      var n = r(70);
+
+      function i(t, e) {
+        t.emit("error", e);
+      }
+
+      t.exports = {
+        destroy: function (t, e) {
+          var r = this,
+              o = this._readableState && this._readableState.destroyed,
+              a = this._writableState && this._writableState.destroyed;
+          return o || a ? (e ? e(t) : !t || this._writableState && this._writableState.errorEmitted || n.nextTick(i, this, t), this) : (this._readableState && (this._readableState.destroyed = !0), this._writableState && (this._writableState.destroyed = !0), this._destroy(t || null, function (t) {
+            !e && t ? (n.nextTick(i, r, t), r._writableState && (r._writableState.errorEmitted = !0)) : e && e(t);
+          }), this);
+        },
+        undestroy: function () {
+          this._readableState && (this._readableState.destroyed = !1, this._readableState.reading = !1, this._readableState.ended = !1, this._readableState.endEmitted = !1), this._writableState && (this._writableState.destroyed = !1, this._writableState.ended = !1, this._writableState.ending = !1, this._writableState.finished = !1, this._writableState.errorEmitted = !1);
+        }
+      };
+    }, function (t, e, r) {
+
+      var n = r(71).Buffer,
+          i = n.isEncoding || function (t) {
+        switch ((t = "" + t) && t.toLowerCase()) {
+          case "hex":
+          case "utf8":
+          case "utf-8":
+          case "ascii":
+          case "binary":
+          case "base64":
+          case "ucs2":
+          case "ucs-2":
+          case "utf16le":
+          case "utf-16le":
+          case "raw":
+            return !0;
+
+          default:
+            return !1;
+        }
+      };
+
+      function o(t) {
+        var e;
+
+        switch (this.encoding = function (t) {
+          var e = function (t) {
+            if (!t) return "utf8";
+
+            for (var e;;) switch (t) {
+              case "utf8":
+              case "utf-8":
+                return "utf8";
+
+              case "ucs2":
+              case "ucs-2":
+              case "utf16le":
+              case "utf-16le":
+                return "utf16le";
+
+              case "latin1":
+              case "binary":
+                return "latin1";
+
+              case "base64":
+              case "ascii":
+              case "hex":
+                return t;
+
+              default:
+                if (e) return;
+                t = ("" + t).toLowerCase(), e = !0;
+            }
+          }(t);
+
+          if ("string" != typeof e && (n.isEncoding === i || !i(t))) throw new Error("Unknown encoding: " + t);
+          return e || t;
+        }(t), this.encoding) {
+          case "utf16le":
+            this.text = u, this.end = f, e = 4;
+            break;
+
+          case "utf8":
+            this.fillLast = s, e = 4;
+            break;
+
+          case "base64":
+            this.text = c, this.end = l, e = 3;
+            break;
+
+          default:
+            return this.write = h, void (this.end = d);
+        }
+
+        this.lastNeed = 0, this.lastTotal = 0, this.lastChar = n.allocUnsafe(e);
+      }
+
+      function a(t) {
+        return t <= 127 ? 0 : t >> 5 == 6 ? 2 : t >> 4 == 14 ? 3 : t >> 3 == 30 ? 4 : t >> 6 == 2 ? -1 : -2;
+      }
+
+      function s(t) {
+        var e = this.lastTotal - this.lastNeed,
+            r = function (t, e, r) {
+          if (128 != (192 & e[0])) return t.lastNeed = 0, "�";
+
+          if (t.lastNeed > 1 && e.length > 1) {
+            if (128 != (192 & e[1])) return t.lastNeed = 1, "�";
+            if (t.lastNeed > 2 && e.length > 2 && 128 != (192 & e[2])) return t.lastNeed = 2, "�";
+          }
+        }(this, t);
+
+        return void 0 !== r ? r : this.lastNeed <= t.length ? (t.copy(this.lastChar, e, 0, this.lastNeed), this.lastChar.toString(this.encoding, 0, this.lastTotal)) : (t.copy(this.lastChar, e, 0, t.length), void (this.lastNeed -= t.length));
+      }
+
+      function u(t, e) {
+        if ((t.length - e) % 2 == 0) {
+          var r = t.toString("utf16le", e);
+
+          if (r) {
+            var n = r.charCodeAt(r.length - 1);
+            if (n >= 55296 && n <= 56319) return this.lastNeed = 2, this.lastTotal = 4, this.lastChar[0] = t[t.length - 2], this.lastChar[1] = t[t.length - 1], r.slice(0, -1);
+          }
+
+          return r;
+        }
+
+        return this.lastNeed = 1, this.lastTotal = 2, this.lastChar[0] = t[t.length - 1], t.toString("utf16le", e, t.length - 1);
+      }
+
+      function f(t) {
+        var e = t && t.length ? this.write(t) : "";
+
+        if (this.lastNeed) {
+          var r = this.lastTotal - this.lastNeed;
+          return e + this.lastChar.toString("utf16le", 0, r);
+        }
+
+        return e;
+      }
+
+      function c(t, e) {
+        var r = (t.length - e) % 3;
+        return 0 === r ? t.toString("base64", e) : (this.lastNeed = 3 - r, this.lastTotal = 3, 1 === r ? this.lastChar[0] = t[t.length - 1] : (this.lastChar[0] = t[t.length - 2], this.lastChar[1] = t[t.length - 1]), t.toString("base64", e, t.length - r));
+      }
+
+      function l(t) {
+        var e = t && t.length ? this.write(t) : "";
+        return this.lastNeed ? e + this.lastChar.toString("base64", 0, 3 - this.lastNeed) : e;
+      }
+
+      function h(t) {
+        return t.toString(this.encoding);
+      }
+
+      function d(t) {
+        return t && t.length ? this.write(t) : "";
+      }
+
+      e.StringDecoder = o, o.prototype.write = function (t) {
+        if (0 === t.length) return "";
+        var e, r;
+
+        if (this.lastNeed) {
+          if (void 0 === (e = this.fillLast(t))) return "";
+          r = this.lastNeed, this.lastNeed = 0;
+        } else r = 0;
+
+        return r < t.length ? e ? e + this.text(t, r) : this.text(t, r) : e || "";
+      }, o.prototype.end = function (t) {
+        var e = t && t.length ? this.write(t) : "";
+        return this.lastNeed ? e + "�" : e;
+      }, o.prototype.text = function (t, e) {
+        var r = function (t, e, r) {
+          var n = e.length - 1;
+          if (n < r) return 0;
+          var i = a(e[n]);
+          if (i >= 0) return i > 0 && (t.lastNeed = i - 1), i;
+          if (--n < r || -2 === i) return 0;
+          if ((i = a(e[n])) >= 0) return i > 0 && (t.lastNeed = i - 2), i;
+          if (--n < r || -2 === i) return 0;
+          if ((i = a(e[n])) >= 0) return i > 0 && (2 === i ? i = 0 : t.lastNeed = i - 3), i;
+          return 0;
+        }(this, t, e);
+
+        if (!this.lastNeed) return t.toString("utf8", e);
+        this.lastTotal = r;
+        var n = t.length - (r - this.lastNeed);
+        return t.copy(this.lastChar, 0, n), t.toString("utf8", e, n);
+      }, o.prototype.fillLast = function (t) {
+        if (this.lastNeed <= t.length) return t.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, this.lastNeed), this.lastChar.toString(this.encoding, 0, this.lastTotal);
+        t.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, t.length), this.lastNeed -= t.length;
+      };
+    }, function (t, e, r) {
+
+      t.exports = a;
+      var n = r(39),
+          i = r(57);
+
+      function o(t, e) {
+        var r = this._transformState;
+        r.transforming = !1;
+        var n = r.writecb;
+        if (!n) return this.emit("error", new Error("write callback called multiple times"));
+        r.writechunk = null, r.writecb = null, null != e && this.push(e), n(t);
+        var i = this._readableState;
+        i.reading = !1, (i.needReadable || i.length < i.highWaterMark) && this._read(i.highWaterMark);
+      }
+
+      function a(t) {
+        if (!(this instanceof a)) return new a(t);
+        n.call(this, t), this._transformState = {
+          afterTransform: o.bind(this),
+          needTransform: !1,
+          transforming: !1,
+          writecb: null,
+          writechunk: null,
+          writeencoding: null
+        }, this._readableState.needReadable = !0, this._readableState.sync = !1, t && ("function" == typeof t.transform && (this._transform = t.transform), "function" == typeof t.flush && (this._flush = t.flush)), this.on("prefinish", s);
+      }
+
+      function s() {
+        var t = this;
+        "function" == typeof this._flush ? this._flush(function (e, r) {
+          u(t, e, r);
+        }) : u(this, null, null);
+      }
+
+      function u(t, e, r) {
+        if (e) return t.emit("error", e);
+        if (null != r && t.push(r), t._writableState.length) throw new Error("Calling transform done when ws.length != 0");
+        if (t._transformState.transforming) throw new Error("Calling transform done when still transforming");
+        return t.push(null);
+      }
+
+      i.inherits = r(47), i.inherits(a, n), a.prototype.push = function (t, e) {
+        return this._transformState.needTransform = !1, n.prototype.push.call(this, t, e);
+      }, a.prototype._transform = function (t, e, r) {
+        throw new Error("_transform() is not implemented");
+      }, a.prototype._write = function (t, e, r) {
+        var n = this._transformState;
+
+        if (n.writecb = r, n.writechunk = t, n.writeencoding = e, !n.transforming) {
+          var i = this._readableState;
+          (n.needTransform || i.needReadable || i.length < i.highWaterMark) && this._read(i.highWaterMark);
+        }
+      }, a.prototype._read = function (t) {
+        var e = this._transformState;
+        null !== e.writechunk && e.writecb && !e.transforming ? (e.transforming = !0, this._transform(e.writechunk, e.writeencoding, e.afterTransform)) : e.needTransform = !0;
+      }, a.prototype._destroy = function (t, e) {
+        var r = this;
+
+        n.prototype._destroy.call(this, t, function (t) {
+          e(t), r.emit("close");
+        });
+      };
+    }, function (t, e, r) {
+
+      (function (e) {
+        var n = r(213);
+        /*!
+         * The buffer module from node.js, for the browser.
+         *
+         * @author   Feross Aboukhadijeh <feross@feross.org> <http://feross.org>
+         * @license  MIT
+         */
+
+        function i(t, e) {
+          if (t === e) return 0;
+
+          for (var r = t.length, n = e.length, i = 0, o = Math.min(r, n); i < o; ++i) if (t[i] !== e[i]) {
+            r = t[i], n = e[i];
+            break;
+          }
+
+          return r < n ? -1 : n < r ? 1 : 0;
+        }
+
+        function o(t) {
+          return e.Buffer && "function" == typeof e.Buffer.isBuffer ? e.Buffer.isBuffer(t) : !(null == t || !t._isBuffer);
+        }
+
+        var a = r(133),
+            s = Object.prototype.hasOwnProperty,
+            u = Array.prototype.slice,
+            f = "foo" === function () {}.name;
+
+        function c(t) {
+          return Object.prototype.toString.call(t);
+        }
+
+        function l(t) {
+          return !o(t) && "function" == typeof e.ArrayBuffer && ("function" == typeof ArrayBuffer.isView ? ArrayBuffer.isView(t) : !!t && (t instanceof DataView || !!(t.buffer && t.buffer instanceof ArrayBuffer)));
+        }
+
+        var h = t.exports = m,
+            d = /\s*function\s+([^\(\s]*)\s*/;
+
+        function p(t) {
+          if (a.isFunction(t)) {
+            if (f) return t.name;
+            var e = t.toString().match(d);
+            return e && e[1];
+          }
+        }
+
+        function g(t, e) {
+          return "string" == typeof t ? t.length < e ? t : t.slice(0, e) : t;
+        }
+
+        function v(t) {
+          if (f || !a.isFunction(t)) return a.inspect(t);
+          var e = p(t);
+          return "[Function" + (e ? ": " + e : "") + "]";
+        }
+
+        function y(t, e, r, n, i) {
+          throw new h.AssertionError({
+            message: r,
+            actual: t,
+            expected: e,
+            operator: n,
+            stackStartFunction: i
+          });
+        }
+
+        function m(t, e) {
+          t || y(t, !0, e, "==", h.ok);
+        }
+
+        function b(t, e, r, n) {
+          if (t === e) return !0;
+          if (o(t) && o(e)) return 0 === i(t, e);
+          if (a.isDate(t) && a.isDate(e)) return t.getTime() === e.getTime();
+          if (a.isRegExp(t) && a.isRegExp(e)) return t.source === e.source && t.global === e.global && t.multiline === e.multiline && t.lastIndex === e.lastIndex && t.ignoreCase === e.ignoreCase;
+
+          if (null !== t && "object" == typeof t || null !== e && "object" == typeof e) {
+            if (l(t) && l(e) && c(t) === c(e) && !(t instanceof Float32Array || t instanceof Float64Array)) return 0 === i(new Uint8Array(t.buffer), new Uint8Array(e.buffer));
+            if (o(t) !== o(e)) return !1;
+            var s = (n = n || {
+              actual: [],
+              expected: []
+            }).actual.indexOf(t);
+            return -1 !== s && s === n.expected.indexOf(e) || (n.actual.push(t), n.expected.push(e), function (t, e, r, n) {
+              if (null == t || null == e) return !1;
+              if (a.isPrimitive(t) || a.isPrimitive(e)) return t === e;
+              if (r && Object.getPrototypeOf(t) !== Object.getPrototypeOf(e)) return !1;
+
+              var i = _(t),
+                  o = _(e);
+
+              if (i && !o || !i && o) return !1;
+              if (i) return t = u.call(t), e = u.call(e), b(t, e, r);
+              var s,
+                  f,
+                  c = E(t),
+                  l = E(e);
+              if (c.length !== l.length) return !1;
+
+              for (c.sort(), l.sort(), f = c.length - 1; f >= 0; f--) if (c[f] !== l[f]) return !1;
+
+              for (f = c.length - 1; f >= 0; f--) if (s = c[f], !b(t[s], e[s], r, n)) return !1;
+
+              return !0;
+            }(t, e, r, n));
+          }
+
+          return r ? t === e : t == e;
+        }
+
+        function _(t) {
+          return "[object Arguments]" == Object.prototype.toString.call(t);
+        }
+
+        function w(t, e) {
+          if (!t || !e) return !1;
+          if ("[object RegExp]" == Object.prototype.toString.call(e)) return e.test(t);
+
+          try {
+            if (t instanceof e) return !0;
+          } catch (t) {}
+
+          return !Error.isPrototypeOf(e) && !0 === e.call({}, t);
+        }
+
+        function x(t, e, r, n) {
+          var i;
+          if ("function" != typeof e) throw new TypeError('"block" argument must be a function');
+          "string" == typeof r && (n = r, r = null), i = function (t) {
+            var e;
+
+            try {
+              t();
+            } catch (t) {
+              e = t;
+            }
+
+            return e;
+          }(e), n = (r && r.name ? " (" + r.name + ")." : ".") + (n ? " " + n : "."), t && !i && y(i, r, "Missing expected exception" + n);
+          var o = "string" == typeof n,
+              s = !t && i && !r;
+          if ((!t && a.isError(i) && o && w(i, r) || s) && y(i, r, "Got unwanted exception" + n), t && i && r && !w(i, r) || !t && i) throw i;
+        }
+
+        h.AssertionError = function (t) {
+          this.name = "AssertionError", this.actual = t.actual, this.expected = t.expected, this.operator = t.operator, t.message ? (this.message = t.message, this.generatedMessage = !1) : (this.message = function (t) {
+            return g(v(t.actual), 128) + " " + t.operator + " " + g(v(t.expected), 128);
+          }(this), this.generatedMessage = !0);
+          var e = t.stackStartFunction || y;
+          if (Error.captureStackTrace) Error.captureStackTrace(this, e);else {
+            var r = new Error();
+
+            if (r.stack) {
+              var n = r.stack,
+                  i = p(e),
+                  o = n.indexOf("\n" + i);
+
+              if (o >= 0) {
+                var a = n.indexOf("\n", o + 1);
+                n = n.substring(a + 1);
+              }
+
+              this.stack = n;
+            }
+          }
+        }, a.inherits(h.AssertionError, Error), h.fail = y, h.ok = m, h.equal = function (t, e, r) {
+          t != e && y(t, e, r, "==", h.equal);
+        }, h.notEqual = function (t, e, r) {
+          t == e && y(t, e, r, "!=", h.notEqual);
+        }, h.deepEqual = function (t, e, r) {
+          b(t, e, !1) || y(t, e, r, "deepEqual", h.deepEqual);
+        }, h.deepStrictEqual = function (t, e, r) {
+          b(t, e, !0) || y(t, e, r, "deepStrictEqual", h.deepStrictEqual);
+        }, h.notDeepEqual = function (t, e, r) {
+          b(t, e, !1) && y(t, e, r, "notDeepEqual", h.notDeepEqual);
+        }, h.notDeepStrictEqual = function t(e, r, n) {
+          b(e, r, !0) && y(e, r, n, "notDeepStrictEqual", t);
+        }, h.strictEqual = function (t, e, r) {
+          t !== e && y(t, e, r, "===", h.strictEqual);
+        }, h.notStrictEqual = function (t, e, r) {
+          t === e && y(t, e, r, "!==", h.notStrictEqual);
+        }, h.throws = function (t, e, r) {
+          x(!0, t, e, r);
+        }, h.doesNotThrow = function (t, e, r) {
+          x(!1, t, e, r);
+        }, h.ifError = function (t) {
+          if (t) throw t;
+        }, h.strict = n(function t(e, r) {
+          e || y(e, !0, r, "==", t);
+        }, h, {
+          equal: h.strictEqual,
+          deepEqual: h.deepStrictEqual,
+          notEqual: h.notStrictEqual,
+          notDeepEqual: h.notDeepStrictEqual
+        }), h.strict.strict = h.strict;
+
+        var E = Object.keys || function (t) {
+          var e = [];
+
+          for (var r in t) s.call(t, r) && e.push(r);
+
+          return e;
+        };
+      }).call(this, r(23));
+    }, function (t, e, r) {
+      (function (t) {
+        var n = Object.getOwnPropertyDescriptors || function (t) {
+          for (var e = Object.keys(t), r = {}, n = 0; n < e.length; n++) r[e[n]] = Object.getOwnPropertyDescriptor(t, e[n]);
+
+          return r;
+        },
+            i = /%[sdj%]/g;
+
+        e.format = function (t) {
+          if (!y(t)) {
+            for (var e = [], r = 0; r < arguments.length; r++) e.push(s(arguments[r]));
+
+            return e.join(" ");
+          }
+
+          r = 1;
+
+          for (var n = arguments, o = n.length, a = String(t).replace(i, function (t) {
+            if ("%%" === t) return "%";
+            if (r >= o) return t;
+
+            switch (t) {
+              case "%s":
+                return String(n[r++]);
+
+              case "%d":
+                return Number(n[r++]);
+
+              case "%j":
+                try {
+                  return JSON.stringify(n[r++]);
+                } catch (t) {
+                  return "[Circular]";
+                }
+
+              default:
+                return t;
+            }
+          }), u = n[r]; r < o; u = n[++r]) g(u) || !_(u) ? a += " " + u : a += " " + s(u);
+
+          return a;
+        }, e.deprecate = function (r, n) {
+          if (void 0 !== t && !0 === t.noDeprecation) return r;
+          if (void 0 === t) return function () {
+            return e.deprecate(r, n).apply(this, arguments);
+          };
+          var i = !1;
+          return function () {
+            if (!i) {
+              if (t.throwDeprecation) throw new Error(n);
+              t.traceDeprecation ? console.trace(n) : console.error(n), i = !0;
+            }
+
+            return r.apply(this, arguments);
+          };
+        };
+        var o,
+            a = {};
+
+        function s(t, r) {
+          var n = {
+            seen: [],
+            stylize: f
+          };
+          return arguments.length >= 3 && (n.depth = arguments[2]), arguments.length >= 4 && (n.colors = arguments[3]), p(r) ? n.showHidden = r : r && e._extend(n, r), m(n.showHidden) && (n.showHidden = !1), m(n.depth) && (n.depth = 2), m(n.colors) && (n.colors = !1), m(n.customInspect) && (n.customInspect = !0), n.colors && (n.stylize = u), c(n, t, n.depth);
+        }
+
+        function u(t, e) {
+          var r = s.styles[e];
+          return r ? "[" + s.colors[r][0] + "m" + t + "[" + s.colors[r][1] + "m" : t;
+        }
+
+        function f(t, e) {
+          return t;
+        }
+
+        function c(t, r, n) {
+          if (t.customInspect && r && E(r.inspect) && r.inspect !== e.inspect && (!r.constructor || r.constructor.prototype !== r)) {
+            var i = r.inspect(n, t);
+            return y(i) || (i = c(t, i, n)), i;
+          }
+
+          var o = function (t, e) {
+            if (m(e)) return t.stylize("undefined", "undefined");
+
+            if (y(e)) {
+              var r = "'" + JSON.stringify(e).replace(/^"|"$/g, "").replace(/'/g, "\\'").replace(/\\"/g, '"') + "'";
+              return t.stylize(r, "string");
+            }
+
+            if (v(e)) return t.stylize("" + e, "number");
+            if (p(e)) return t.stylize("" + e, "boolean");
+            if (g(e)) return t.stylize("null", "null");
+          }(t, r);
+
+          if (o) return o;
+
+          var a = Object.keys(r),
+              s = function (t) {
+            var e = {};
+            return t.forEach(function (t, r) {
+              e[t] = !0;
+            }), e;
+          }(a);
+
+          if (t.showHidden && (a = Object.getOwnPropertyNames(r)), x(r) && (a.indexOf("message") >= 0 || a.indexOf("description") >= 0)) return l(r);
+
+          if (0 === a.length) {
+            if (E(r)) {
+              var u = r.name ? ": " + r.name : "";
+              return t.stylize("[Function" + u + "]", "special");
+            }
+
+            if (b(r)) return t.stylize(RegExp.prototype.toString.call(r), "regexp");
+            if (w(r)) return t.stylize(Date.prototype.toString.call(r), "date");
+            if (x(r)) return l(r);
+          }
+
+          var f,
+              _ = "",
+              S = !1,
+              k = ["{", "}"];
+          (d(r) && (S = !0, k = ["[", "]"]), E(r)) && (_ = " [Function" + (r.name ? ": " + r.name : "") + "]");
+          return b(r) && (_ = " " + RegExp.prototype.toString.call(r)), w(r) && (_ = " " + Date.prototype.toUTCString.call(r)), x(r) && (_ = " " + l(r)), 0 !== a.length || S && 0 != r.length ? n < 0 ? b(r) ? t.stylize(RegExp.prototype.toString.call(r), "regexp") : t.stylize("[Object]", "special") : (t.seen.push(r), f = S ? function (t, e, r, n, i) {
+            for (var o = [], a = 0, s = e.length; a < s; ++a) T(e, String(a)) ? o.push(h(t, e, r, n, String(a), !0)) : o.push("");
+
+            return i.forEach(function (i) {
+              i.match(/^\d+$/) || o.push(h(t, e, r, n, i, !0));
+            }), o;
+          }(t, r, n, s, a) : a.map(function (e) {
+            return h(t, r, n, s, e, S);
+          }), t.seen.pop(), function (t, e, r) {
+            if (t.reduce(function (t, e) {
+              return e.indexOf("\n") >= 0 && 0, t + e.replace(/\u001b\[\d\d?m/g, "").length + 1;
+            }, 0) > 60) return r[0] + ("" === e ? "" : e + "\n ") + " " + t.join(",\n  ") + " " + r[1];
+            return r[0] + e + " " + t.join(", ") + " " + r[1];
+          }(f, _, k)) : k[0] + _ + k[1];
+        }
+
+        function l(t) {
+          return "[" + Error.prototype.toString.call(t) + "]";
+        }
+
+        function h(t, e, r, n, i, o) {
+          var a, s, u;
+
+          if ((u = Object.getOwnPropertyDescriptor(e, i) || {
+            value: e[i]
+          }).get ? s = u.set ? t.stylize("[Getter/Setter]", "special") : t.stylize("[Getter]", "special") : u.set && (s = t.stylize("[Setter]", "special")), T(n, i) || (a = "[" + i + "]"), s || (t.seen.indexOf(u.value) < 0 ? (s = g(r) ? c(t, u.value, null) : c(t, u.value, r - 1)).indexOf("\n") > -1 && (s = o ? s.split("\n").map(function (t) {
+            return "  " + t;
+          }).join("\n").substr(2) : "\n" + s.split("\n").map(function (t) {
+            return "   " + t;
+          }).join("\n")) : s = t.stylize("[Circular]", "special")), m(a)) {
+            if (o && i.match(/^\d+$/)) return s;
+            (a = JSON.stringify("" + i)).match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/) ? (a = a.substr(1, a.length - 2), a = t.stylize(a, "name")) : (a = a.replace(/'/g, "\\'").replace(/\\"/g, '"').replace(/(^"|"$)/g, "'"), a = t.stylize(a, "string"));
+          }
+
+          return a + ": " + s;
+        }
+
+        function d(t) {
+          return Array.isArray(t);
+        }
+
+        function p(t) {
+          return "boolean" == typeof t;
+        }
+
+        function g(t) {
+          return null === t;
+        }
+
+        function v(t) {
+          return "number" == typeof t;
+        }
+
+        function y(t) {
+          return "string" == typeof t;
+        }
+
+        function m(t) {
+          return void 0 === t;
+        }
+
+        function b(t) {
+          return _(t) && "[object RegExp]" === S(t);
+        }
+
+        function _(t) {
+          return "object" == typeof t && null !== t;
+        }
+
+        function w(t) {
+          return _(t) && "[object Date]" === S(t);
+        }
+
+        function x(t) {
+          return _(t) && ("[object Error]" === S(t) || t instanceof Error);
+        }
+
+        function E(t) {
+          return "function" == typeof t;
+        }
+
+        function S(t) {
+          return Object.prototype.toString.call(t);
+        }
+
+        e.debuglog = function (r) {
+          if (m(o) && (o = t.env.NODE_DEBUG || ""), r = r.toUpperCase(), !a[r]) if (new RegExp("\\b" + r + "\\b", "i").test(o)) {
+            var n = t.pid;
+
+            a[r] = function () {
+              var t = e.format.apply(e, arguments);
+              console.error("%s %d: %s", r, n, t);
+            };
+          } else a[r] = function () {};
+          return a[r];
+        }, e.inspect = s, s.colors = {
+          bold: [1, 22],
+          italic: [3, 23],
+          underline: [4, 24],
+          inverse: [7, 27],
+          white: [37, 39],
+          grey: [90, 39],
+          black: [30, 39],
+          blue: [34, 39],
+          cyan: [36, 39],
+          green: [32, 39],
+          magenta: [35, 39],
+          red: [31, 39],
+          yellow: [33, 39]
+        }, s.styles = {
+          special: "cyan",
+          number: "yellow",
+          boolean: "yellow",
+          undefined: "grey",
+          null: "bold",
+          string: "green",
+          date: "magenta",
+          regexp: "red"
+        }, e.isArray = d, e.isBoolean = p, e.isNull = g, e.isNullOrUndefined = function (t) {
+          return null == t;
+        }, e.isNumber = v, e.isString = y, e.isSymbol = function (t) {
+          return "symbol" == typeof t;
+        }, e.isUndefined = m, e.isRegExp = b, e.isObject = _, e.isDate = w, e.isError = x, e.isFunction = E, e.isPrimitive = function (t) {
+          return null === t || "boolean" == typeof t || "number" == typeof t || "string" == typeof t || "symbol" == typeof t || void 0 === t;
+        }, e.isBuffer = r(214);
+
+        function T(t, e) {
+          return Object.prototype.hasOwnProperty.call(t, e);
+        }
+
+        e.log = function () {}, e.inherits = r(215), e._extend = function (t, e) {
+          if (!e || !_(e)) return t;
+
+          for (var r = Object.keys(e), n = r.length; n--;) t[r[n]] = e[r[n]];
+
+          return t;
+        };
+        var R = "undefined" != typeof Symbol ? Symbol("util.promisify.custom") : void 0;
+
+        function O(t, e) {
+          if (!t) {
+            var r = new Error("Promise was rejected with a falsy value");
+            r.reason = t, t = r;
+          }
+
+          return e(t);
+        }
+
+        e.promisify = function (t) {
+          if ("function" != typeof t) throw new TypeError('The "original" argument must be of type Function');
+
+          if (R && t[R]) {
+            var e;
+            if ("function" != typeof (e = t[R])) throw new TypeError('The "util.promisify.custom" argument must be of type Function');
+            return Object.defineProperty(e, R, {
+              value: e,
+              enumerable: !1,
+              writable: !1,
+              configurable: !0
+            }), e;
+          }
+
+          function e() {
+            for (var e, r, n = new Promise(function (t, n) {
+              e = t, r = n;
+            }), i = [], o = 0; o < arguments.length; o++) i.push(arguments[o]);
+
+            i.push(function (t, n) {
+              t ? r(t) : e(n);
+            });
+
+            try {
+              t.apply(this, i);
+            } catch (t) {
+              r(t);
+            }
+
+            return n;
+          }
+
+          return Object.setPrototypeOf(e, Object.getPrototypeOf(t)), R && Object.defineProperty(e, R, {
+            value: e,
+            enumerable: !1,
+            writable: !1,
+            configurable: !0
+          }), Object.defineProperties(e, n(t));
+        }, e.promisify.custom = R, e.callbackify = function (e) {
+          if ("function" != typeof e) throw new TypeError('The "original" argument must be of type Function');
+
+          function r() {
+            for (var r = [], n = 0; n < arguments.length; n++) r.push(arguments[n]);
+
+            var i = r.pop();
+            if ("function" != typeof i) throw new TypeError("The last argument must be of type Function");
+
+            var o = this,
+                a = function () {
+              return i.apply(o, arguments);
+            };
+
+            e.apply(this, r).then(function (e) {
+              t.nextTick(a, null, e);
+            }, function (e) {
+              t.nextTick(O, e, a);
+            });
+          }
+
+          return Object.setPrototypeOf(r, Object.getPrototypeOf(e)), Object.defineProperties(r, n(e)), r;
+        };
+      }).call(this, r(38));
+    }, function (t, e, r) {
+
+      t.exports = function (t, e, r, n) {
+        for (var i = 65535 & t | 0, o = t >>> 16 & 65535 | 0, a = 0; 0 !== r;) {
+          r -= a = r > 2e3 ? 2e3 : r;
+
+          do {
+            o = o + (i = i + e[n++] | 0) | 0;
+          } while (--a);
+
+          i %= 65521, o %= 65521;
+        }
+
+        return i | o << 16 | 0;
+      };
+    }, function (t, e, r) {
+
+      var n = function () {
+        for (var t, e = [], r = 0; r < 256; r++) {
+          t = r;
+
+          for (var n = 0; n < 8; n++) t = 1 & t ? 3988292384 ^ t >>> 1 : t >>> 1;
+
+          e[r] = t;
+        }
+
+        return e;
+      }();
+
+      t.exports = function (t, e, r, i) {
+        var o = n,
+            a = i + r;
+        t ^= -1;
+
+        for (var s = i; s < a; s++) t = t >>> 8 ^ o[255 & (t ^ e[s])];
+
+        return -1 ^ t;
+      };
+    }, function (t, e, r) {
+      r(11)("iterator");
+    }, function (t, e, r) {
+      var n = r(111),
+          i = r(85).concat("length", "prototype");
+
+      e.f = Object.getOwnPropertyNames || function (t) {
+        return n(t, i);
+      };
+    }, function (t, e) {
+      e.f = Object.getOwnPropertySymbols;
+    }, function (t, e, r) {
+      t.exports = r(259);
+    }, function (t, e, r) {
+      t.exports = r(262);
+    }, function (t, e, r) {
+      var n = r(50),
+          i = r(14),
+          o = r(24),
+          a = r(21).f,
+          s = r(64),
+          u = r(271),
+          f = s("meta"),
+          c = 0,
+          l = Object.isExtensible || function () {
+        return !0;
+      },
+          h = function (t) {
+        a(t, f, {
+          value: {
+            objectID: "O" + ++c,
+            weakData: {}
+          }
+        });
+      },
+          d = t.exports = {
+        REQUIRED: !1,
+        fastKey: function (t, e) {
+          if (!i(t)) return "symbol" == typeof t ? t : ("string" == typeof t ? "S" : "P") + t;
+
+          if (!o(t, f)) {
+            if (!l(t)) return "F";
+            if (!e) return "E";
+            h(t);
+          }
+
+          return t[f].objectID;
+        },
+        getWeakData: function (t, e) {
+          if (!o(t, f)) {
+            if (!l(t)) return !0;
+            if (!e) return !1;
+            h(t);
+          }
+
+          return t[f].weakData;
+        },
+        onFreeze: function (t) {
+          return u && d.REQUIRED && l(t) && !o(t, f) && h(t), t;
+        }
+      };
+
+      n[f] = !0;
+    }, function (t, e, r) {
+      var n = r(2),
+          i = r(90);
+
+      t.exports = function (t) {
+        var e = i(t);
+        if ("function" != typeof e) throw TypeError(String(t) + " is not iterable");
+        return n(e.call(t));
+      };
+    }, function (t, e, r) {
+      var n = r(298),
+          i = Array.prototype;
+
+      t.exports = function (t) {
+        var e = t.indexOf;
+        return t === i || t instanceof Array && e === i.indexOf ? n : e;
+      };
+    }, function (t, e, r) {
+      var n = r(303),
+          i = Function.prototype;
+
+      t.exports = function (t) {
+        var e = t.bind;
+        return t === i || t instanceof Function && e === i.bind ? n : e;
+      };
+    }, function (t, e, r) {
+
+      var n = r(5),
+          i = r(14),
+          o = [].slice,
+          a = {},
+          s = function (t, e, r) {
+        if (!(e in a)) {
+          for (var n = [], i = 0; i < e; i++) n[i] = "a[" + i + "]";
+
+          a[e] = Function("C,a", "return new C(" + n.join(",") + ")");
+        }
+
+        return a[e](t, r);
+      };
+
+      t.exports = Function.bind || function (t) {
+        var e = n(this),
+            r = o.call(arguments, 1),
+            a = function () {
+          var n = r.concat(o.call(arguments));
+          return this instanceof a ? s(e, n.length, n) : e.apply(t, n);
+        };
+
+        return i(e.prototype) && (a.prototype = e.prototype), a;
+      };
+    }, function (t, e) {
+      t.exports = n;
+      var r = null;
+
+      try {
+        r = new WebAssembly.Instance(new WebAssembly.Module(new Uint8Array([0, 97, 115, 109, 1, 0, 0, 0, 1, 13, 2, 96, 0, 1, 127, 96, 4, 127, 127, 127, 127, 1, 127, 3, 7, 6, 0, 1, 1, 1, 1, 1, 6, 6, 1, 127, 1, 65, 0, 11, 7, 50, 6, 3, 109, 117, 108, 0, 1, 5, 100, 105, 118, 95, 115, 0, 2, 5, 100, 105, 118, 95, 117, 0, 3, 5, 114, 101, 109, 95, 115, 0, 4, 5, 114, 101, 109, 95, 117, 0, 5, 8, 103, 101, 116, 95, 104, 105, 103, 104, 0, 0, 10, 191, 1, 6, 4, 0, 35, 0, 11, 36, 1, 1, 126, 32, 0, 173, 32, 1, 173, 66, 32, 134, 132, 32, 2, 173, 32, 3, 173, 66, 32, 134, 132, 126, 34, 4, 66, 32, 135, 167, 36, 0, 32, 4, 167, 11, 36, 1, 1, 126, 32, 0, 173, 32, 1, 173, 66, 32, 134, 132, 32, 2, 173, 32, 3, 173, 66, 32, 134, 132, 127, 34, 4, 66, 32, 135, 167, 36, 0, 32, 4, 167, 11, 36, 1, 1, 126, 32, 0, 173, 32, 1, 173, 66, 32, 134, 132, 32, 2, 173, 32, 3, 173, 66, 32, 134, 132, 128, 34, 4, 66, 32, 135, 167, 36, 0, 32, 4, 167, 11, 36, 1, 1, 126, 32, 0, 173, 32, 1, 173, 66, 32, 134, 132, 32, 2, 173, 32, 3, 173, 66, 32, 134, 132, 129, 34, 4, 66, 32, 135, 167, 36, 0, 32, 4, 167, 11, 36, 1, 1, 126, 32, 0, 173, 32, 1, 173, 66, 32, 134, 132, 32, 2, 173, 32, 3, 173, 66, 32, 134, 132, 130, 34, 4, 66, 32, 135, 167, 36, 0, 32, 4, 167, 11])), {}).exports;
+      } catch (t) {}
+
+      function n(t, e, r) {
+        this.low = 0 | t, this.high = 0 | e, this.unsigned = !!r;
+      }
+
+      function i(t) {
+        return !0 === (t && t.__isLong__);
+      }
+
+      n.prototype.__isLong__, Object.defineProperty(n.prototype, "__isLong__", {
+        value: !0
+      }), n.isLong = i;
+      var o = {},
+          a = {};
+
+      function s(t, e) {
+        var r, n, i;
+        return e ? (i = 0 <= (t >>>= 0) && t < 256) && (n = a[t]) ? n : (r = f(t, (0 | t) < 0 ? -1 : 0, !0), i && (a[t] = r), r) : (i = -128 <= (t |= 0) && t < 128) && (n = o[t]) ? n : (r = f(t, t < 0 ? -1 : 0, !1), i && (o[t] = r), r);
+      }
+
+      function u(t, e) {
+        if (isNaN(t)) return e ? m : y;
+
+        if (e) {
+          if (t < 0) return m;
+          if (t >= p) return E;
+        } else {
+          if (t <= -g) return S;
+          if (t + 1 >= g) return x;
+        }
+
+        return t < 0 ? u(-t, e).neg() : f(t % d | 0, t / d | 0, e);
+      }
+
+      function f(t, e, r) {
+        return new n(t, e, r);
+      }
+
+      n.fromInt = s, n.fromNumber = u, n.fromBits = f;
+      var c = Math.pow;
+
+      function l(t, e, r) {
+        if (0 === t.length) throw Error("empty string");
+        if ("NaN" === t || "Infinity" === t || "+Infinity" === t || "-Infinity" === t) return y;
+        if ("number" == typeof e ? (r = e, e = !1) : e = !!e, (r = r || 10) < 2 || 36 < r) throw RangeError("radix");
+        var n;
+        if ((n = t.indexOf("-")) > 0) throw Error("interior hyphen");
+        if (0 === n) return l(t.substring(1), e, r).neg();
+
+        for (var i = u(c(r, 8)), o = y, a = 0; a < t.length; a += 8) {
+          var s = Math.min(8, t.length - a),
+              f = parseInt(t.substring(a, a + s), r);
+
+          if (s < 8) {
+            var h = u(c(r, s));
+            o = o.mul(h).add(u(f));
+          } else o = (o = o.mul(i)).add(u(f));
+        }
+
+        return o.unsigned = e, o;
+      }
+
+      function h(t, e) {
+        return "number" == typeof t ? u(t, e) : "string" == typeof t ? l(t, e) : f(t.low, t.high, "boolean" == typeof e ? e : t.unsigned);
+      }
+
+      n.fromString = l, n.fromValue = h;
+      var d = 4294967296,
+          p = d * d,
+          g = p / 2,
+          v = s(1 << 24),
+          y = s(0);
+      n.ZERO = y;
+      var m = s(0, !0);
+      n.UZERO = m;
+      var b = s(1);
+      n.ONE = b;
+
+      var _ = s(1, !0);
+
+      n.UONE = _;
+      var w = s(-1);
+      n.NEG_ONE = w;
+      var x = f(-1, 2147483647, !1);
+      n.MAX_VALUE = x;
+      var E = f(-1, -1, !0);
+      n.MAX_UNSIGNED_VALUE = E;
+      var S = f(0, -2147483648, !1);
+      n.MIN_VALUE = S;
+      var k = n.prototype;
+      k.toInt = function () {
+        return this.unsigned ? this.low >>> 0 : this.low;
+      }, k.toNumber = function () {
+        return this.unsigned ? (this.high >>> 0) * d + (this.low >>> 0) : this.high * d + (this.low >>> 0);
+      }, k.toString = function (t) {
+        if ((t = t || 10) < 2 || 36 < t) throw RangeError("radix");
+        if (this.isZero()) return "0";
+
+        if (this.isNegative()) {
+          if (this.eq(S)) {
+            var e = u(t),
+                r = this.div(e),
+                n = r.mul(e).sub(this);
+            return r.toString(t) + n.toInt().toString(t);
+          }
+
+          return "-" + this.neg().toString(t);
+        }
+
+        for (var i = u(c(t, 6), this.unsigned), o = this, a = "";;) {
+          var s = o.div(i),
+              f = (o.sub(s.mul(i)).toInt() >>> 0).toString(t);
+          if ((o = s).isZero()) return f + a;
+
+          for (; f.length < 6;) f = "0" + f;
+
+          a = "" + f + a;
+        }
+      }, k.getHighBits = function () {
+        return this.high;
+      }, k.getHighBitsUnsigned = function () {
+        return this.high >>> 0;
+      }, k.getLowBits = function () {
+        return this.low;
+      }, k.getLowBitsUnsigned = function () {
+        return this.low >>> 0;
+      }, k.getNumBitsAbs = function () {
+        if (this.isNegative()) return this.eq(S) ? 64 : this.neg().getNumBitsAbs();
+
+        for (var t = 0 != this.high ? this.high : this.low, e = 31; e > 0 && 0 == (t & 1 << e); e--);
+
+        return 0 != this.high ? e + 33 : e + 1;
+      }, k.isZero = function () {
+        return 0 === this.high && 0 === this.low;
+      }, k.eqz = k.isZero, k.isNegative = function () {
+        return !this.unsigned && this.high < 0;
+      }, k.isPositive = function () {
+        return this.unsigned || this.high >= 0;
+      }, k.isOdd = function () {
+        return 1 == (1 & this.low);
+      }, k.isEven = function () {
+        return 0 == (1 & this.low);
+      }, k.equals = function (t) {
+        return i(t) || (t = h(t)), (this.unsigned === t.unsigned || this.high >>> 31 != 1 || t.high >>> 31 != 1) && this.high === t.high && this.low === t.low;
+      }, k.eq = k.equals, k.notEquals = function (t) {
+        return !this.eq(t);
+      }, k.neq = k.notEquals, k.ne = k.notEquals, k.lessThan = function (t) {
+        return this.comp(t) < 0;
+      }, k.lt = k.lessThan, k.lessThanOrEqual = function (t) {
+        return this.comp(t) <= 0;
+      }, k.lte = k.lessThanOrEqual, k.le = k.lessThanOrEqual, k.greaterThan = function (t) {
+        return this.comp(t) > 0;
+      }, k.gt = k.greaterThan, k.greaterThanOrEqual = function (t) {
+        return this.comp(t) >= 0;
+      }, k.gte = k.greaterThanOrEqual, k.ge = k.greaterThanOrEqual, k.compare = function (t) {
+        if (i(t) || (t = h(t)), this.eq(t)) return 0;
+        var e = this.isNegative(),
+            r = t.isNegative();
+        return e && !r ? -1 : !e && r ? 1 : this.unsigned ? t.high >>> 0 > this.high >>> 0 || t.high === this.high && t.low >>> 0 > this.low >>> 0 ? -1 : 1 : this.sub(t).isNegative() ? -1 : 1;
+      }, k.comp = k.compare, k.negate = function () {
+        return !this.unsigned && this.eq(S) ? S : this.not().add(b);
+      }, k.neg = k.negate, k.add = function (t) {
+        i(t) || (t = h(t));
+        var e = this.high >>> 16,
+            r = 65535 & this.high,
+            n = this.low >>> 16,
+            o = 65535 & this.low,
+            a = t.high >>> 16,
+            s = 65535 & t.high,
+            u = t.low >>> 16,
+            c = 0,
+            l = 0,
+            d = 0,
+            p = 0;
+        return d += (p += o + (65535 & t.low)) >>> 16, l += (d += n + u) >>> 16, c += (l += r + s) >>> 16, c += e + a, f((d &= 65535) << 16 | (p &= 65535), (c &= 65535) << 16 | (l &= 65535), this.unsigned);
+      }, k.subtract = function (t) {
+        return i(t) || (t = h(t)), this.add(t.neg());
+      }, k.sub = k.subtract, k.multiply = function (t) {
+        if (this.isZero()) return y;
+        if (i(t) || (t = h(t)), r) return f(r.mul(this.low, this.high, t.low, t.high), r.get_high(), this.unsigned);
+        if (t.isZero()) return y;
+        if (this.eq(S)) return t.isOdd() ? S : y;
+        if (t.eq(S)) return this.isOdd() ? S : y;
+        if (this.isNegative()) return t.isNegative() ? this.neg().mul(t.neg()) : this.neg().mul(t).neg();
+        if (t.isNegative()) return this.mul(t.neg()).neg();
+        if (this.lt(v) && t.lt(v)) return u(this.toNumber() * t.toNumber(), this.unsigned);
+        var e = this.high >>> 16,
+            n = 65535 & this.high,
+            o = this.low >>> 16,
+            a = 65535 & this.low,
+            s = t.high >>> 16,
+            c = 65535 & t.high,
+            l = t.low >>> 16,
+            d = 65535 & t.low,
+            p = 0,
+            g = 0,
+            m = 0,
+            b = 0;
+        return m += (b += a * d) >>> 16, g += (m += o * d) >>> 16, m &= 65535, g += (m += a * l) >>> 16, p += (g += n * d) >>> 16, g &= 65535, p += (g += o * l) >>> 16, g &= 65535, p += (g += a * c) >>> 16, p += e * d + n * l + o * c + a * s, f((m &= 65535) << 16 | (b &= 65535), (p &= 65535) << 16 | (g &= 65535), this.unsigned);
+      }, k.mul = k.multiply, k.divide = function (t) {
+        if (i(t) || (t = h(t)), t.isZero()) throw Error("division by zero");
+        var e, n, o;
+        if (r) return this.unsigned || -2147483648 !== this.high || -1 !== t.low || -1 !== t.high ? f((this.unsigned ? r.div_u : r.div_s)(this.low, this.high, t.low, t.high), r.get_high(), this.unsigned) : this;
+        if (this.isZero()) return this.unsigned ? m : y;
+
+        if (this.unsigned) {
+          if (t.unsigned || (t = t.toUnsigned()), t.gt(this)) return m;
+          if (t.gt(this.shru(1))) return _;
+          o = m;
+        } else {
+          if (this.eq(S)) return t.eq(b) || t.eq(w) ? S : t.eq(S) ? b : (e = this.shr(1).div(t).shl(1)).eq(y) ? t.isNegative() ? b : w : (n = this.sub(t.mul(e)), o = e.add(n.div(t)));
+          if (t.eq(S)) return this.unsigned ? m : y;
+          if (this.isNegative()) return t.isNegative() ? this.neg().div(t.neg()) : this.neg().div(t).neg();
+          if (t.isNegative()) return this.div(t.neg()).neg();
+          o = y;
+        }
+
+        for (n = this; n.gte(t);) {
+          e = Math.max(1, Math.floor(n.toNumber() / t.toNumber()));
+
+          for (var a = Math.ceil(Math.log(e) / Math.LN2), s = a <= 48 ? 1 : c(2, a - 48), l = u(e), d = l.mul(t); d.isNegative() || d.gt(n);) d = (l = u(e -= s, this.unsigned)).mul(t);
+
+          l.isZero() && (l = b), o = o.add(l), n = n.sub(d);
+        }
+
+        return o;
+      }, k.div = k.divide, k.modulo = function (t) {
+        return i(t) || (t = h(t)), r ? f((this.unsigned ? r.rem_u : r.rem_s)(this.low, this.high, t.low, t.high), r.get_high(), this.unsigned) : this.sub(this.div(t).mul(t));
+      }, k.mod = k.modulo, k.rem = k.modulo, k.not = function () {
+        return f(~this.low, ~this.high, this.unsigned);
+      }, k.and = function (t) {
+        return i(t) || (t = h(t)), f(this.low & t.low, this.high & t.high, this.unsigned);
+      }, k.or = function (t) {
+        return i(t) || (t = h(t)), f(this.low | t.low, this.high | t.high, this.unsigned);
+      }, k.xor = function (t) {
+        return i(t) || (t = h(t)), f(this.low ^ t.low, this.high ^ t.high, this.unsigned);
+      }, k.shiftLeft = function (t) {
+        return i(t) && (t = t.toInt()), 0 == (t &= 63) ? this : t < 32 ? f(this.low << t, this.high << t | this.low >>> 32 - t, this.unsigned) : f(0, this.low << t - 32, this.unsigned);
+      }, k.shl = k.shiftLeft, k.shiftRight = function (t) {
+        return i(t) && (t = t.toInt()), 0 == (t &= 63) ? this : t < 32 ? f(this.low >>> t | this.high << 32 - t, this.high >> t, this.unsigned) : f(this.high >> t - 32, this.high >= 0 ? 0 : -1, this.unsigned);
+      }, k.shr = k.shiftRight, k.shiftRightUnsigned = function (t) {
+        if (i(t) && (t = t.toInt()), 0 === (t &= 63)) return this;
+        var e = this.high;
+        return t < 32 ? f(this.low >>> t | e << 32 - t, e >>> t, this.unsigned) : f(32 === t ? e : e >>> t - 32, 0, this.unsigned);
+      }, k.shru = k.shiftRightUnsigned, k.shr_u = k.shiftRightUnsigned, k.toSigned = function () {
+        return this.unsigned ? f(this.low, this.high, !1) : this;
+      }, k.toUnsigned = function () {
+        return this.unsigned ? this : f(this.low, this.high, !0);
+      }, k.toBytes = function (t) {
+        return t ? this.toBytesLE() : this.toBytesBE();
+      }, k.toBytesLE = function () {
+        var t = this.high,
+            e = this.low;
+        return [255 & e, e >>> 8 & 255, e >>> 16 & 255, e >>> 24, 255 & t, t >>> 8 & 255, t >>> 16 & 255, t >>> 24];
+      }, k.toBytesBE = function () {
+        var t = this.high,
+            e = this.low;
+        return [t >>> 24, t >>> 16 & 255, t >>> 8 & 255, 255 & t, e >>> 24, e >>> 16 & 255, e >>> 8 & 255, 255 & e];
+      }, n.fromBytes = function (t, e, r) {
+        return r ? n.fromBytesLE(t, e) : n.fromBytesBE(t, e);
+      }, n.fromBytesLE = function (t, e) {
+        return new n(t[0] | t[1] << 8 | t[2] << 16 | t[3] << 24, t[4] | t[5] << 8 | t[6] << 16 | t[7] << 24, e);
+      }, n.fromBytesBE = function (t, e) {
+        return new n(t[4] << 24 | t[5] << 16 | t[6] << 8 | t[7], t[0] << 24 | t[1] << 16 | t[2] << 8 | t[3], e);
+      };
+    }, function (t, e) {
+      var r = {
+        utf8: {
+          stringToBytes: function (t) {
+            return r.bin.stringToBytes(unescape(encodeURIComponent(t)));
+          },
+          bytesToString: function (t) {
+            return decodeURIComponent(escape(r.bin.bytesToString(t)));
+          }
+        },
+        bin: {
+          stringToBytes: function (t) {
+            for (var e = [], r = 0; r < t.length; r++) e.push(255 & t.charCodeAt(r));
+
+            return e;
+          },
+          bytesToString: function (t) {
+            for (var e = [], r = 0; r < t.length; r++) e.push(String.fromCharCode(t[r]));
+
+            return e.join("");
+          }
+        }
+      };
+      t.exports = r;
+    }, function (t, e, r) {
+      t.exports = r(335);
+    }, function (t, e, r) {
+      var n = r(17),
+          i = r(51),
+          o = r(28),
+          a = r(65).f,
+          s = function (t) {
+        return function (e) {
+          for (var r, s = o(e), u = i(s), f = u.length, c = 0, l = []; f > c;) r = u[c++], n && !a.call(s, r) || l.push(t ? [r, s[r]] : s[r]);
+
+          return l;
+        };
+      };
+
+      t.exports = {
+        entries: s(!0),
+        values: s(!1)
+      };
+    }, function (t, e, r) {
+      t.exports = r(338);
+    }, function (t, e, r) {
+      t.exports = r(352);
+    }, function (t, e, r) {
+      var n = r(355),
+          i = r(153);
+
+      t.exports = function (t) {
+        if (i(Object(t)) || "[object Arguments]" === Object.prototype.toString.call(t)) return n(t);
+      };
+    }, function (t, e, r) {
+      t.exports = r(360);
+    }, function (t, e, r) {
+      t.exports = r(372);
+    }, function (t, e, r) {
+      var n = r(13),
+          i = r(375).trim,
+          o = r(156),
+          a = n.parseInt,
+          s = /^[+-]?0[Xx]/,
+          u = 8 !== a(o + "08") || 22 !== a(o + "0x16");
+      t.exports = u ? function (t, e) {
+        var r = i(String(t));
+        return a(r, e >>> 0 || (s.test(r) ? 16 : 10));
+      } : a;
+    }, function (t, e) {
+      t.exports = "\t\n\v\f\r                　\u2028\u2029\ufeff";
+    }, function (t, e, r) {
+      var n = r(151);
+
+      t.exports = function (t) {
+        if (n(t)) return t;
+      };
+    }, function (t, e) {
+      t.exports = function () {
+        throw new TypeError("Invalid attempt to destructure non-iterable instance");
+      };
+    }, function (t, e, r) {
+      t.exports = r(393);
+    }, function (t, e, r) {
+
+      var n = r(419),
+          i = r(426),
+          o = r(429);
+
+      function a(t) {
+        var e = n.parse(t),
+            r = e.protocol,
+            a = e.pathname;
+        return "file:" === r ? new o(unescape(a)) : new i(t);
+      }
+
+      t.exports = {
+        LocalFile: o,
+        RemoteFile: i,
+        fromUrl: a,
+        open: function (t, e, r) {
+          if (r) return r;
+          if (t) return a(t);
+          if (e) return new o(e);
+          throw new Error("no url, path, or filehandle provided, cannot open");
+        }
+      };
+    }, function (t, e, r) {
+
+      Object.defineProperty(e, "__esModule", {
+        value: !0
+      }), e.promisify = i;
+      var n = "__ES6-PROMISIFY--CUSTOM-ARGUMENTS__";
+
+      function i(t) {
+        if ("function" != typeof t) throw new TypeError("Argument to promisify must be a function");
+        var e = t[n],
+            r = i.Promise || Promise;
+        if ("function" != typeof r) throw new Error("No Promise implementation found; do you need a polyfill?");
+        return function () {
+          for (var n = this, i = arguments.length, o = new Array(i), a = 0; a < i; a++) o[a] = arguments[a];
+
+          return new r(function (r, i) {
+            o.push(function (t) {
+              if (t) return i(t);
+
+              for (var n = arguments.length, o = new Array(n > 1 ? n - 1 : 0), a = 1; a < n; a++) o[a - 1] = arguments[a];
+
+              if (1 === o.length || !e) return r(o[0]);
+              var s = {};
+              o.forEach(function (t, r) {
+                var n = e[r];
+                n && (s[n] = t);
+              }), r(s);
+            }), t.call.apply(t, [n].concat(o));
+          });
+        };
+      }
+
+      i.argumentNames = n, i.Promise = void 0;
+    }, function (t, e, r) {
+
+      (function (t) {
+        Object.defineProperty(e, "__esModule", {
+          value: !0
+        });
+
+        var n = r(449),
+            i = function () {
+          if ("undefined" != typeof self) return self;
+          if ("undefined" != typeof window) return window;
+          if (void 0 !== t) return t;
+          throw new Error("unable to locate global object");
+        },
+            o = void 0 === i().AbortController ? n.AbortController : i().AbortController;
+
+        e.AbortController = o;
+        var a = void 0 === i().AbortController ? n.AbortSignal : i().AbortSignal;
+        e.AbortSignal = a;
+      }).call(this, r(23));
+    }, function (t, e, r) {
+
+      var n = r(104),
+          i = r(432),
+          o = r(439);
+      t.exports = {
+        CramFile: n,
+        IndexedCramFile: i,
+        CraiIndex: o
+      };
+    }, function (t, e, r) {
+
+      (function (e) {
+        var n,
+            i = r(1),
+            o = i(r(16)),
+            a = i(r(37)),
+            s = i(r(30)),
+            u = i(r(31)),
+            f = i(r(7)),
+            c = i(r(10)),
+            l = r(126),
+            h = r(224),
+            d = r(94),
+            p = r(9),
+            g = p.CramUnimplementedError,
+            v = p.CramMalformedError,
+            y = r(309),
+            m = r(318),
+            b = m.cramFileDefinition,
+            _ = m.getSectionParsers,
+            w = r(329),
+            x = r(160).open,
+            E = r(58),
+            S = E.parseItem,
+            k = E.tinyMemoize,
+            A = r(430).parseHeaderText,
+            C = function () {
+          function t(e) {
+            (0, f.default)(this, t), this.file = x(e.url, e.path, e.filehandle), this.validateChecksums = !0, this.fetchReferenceSequenceCallback = e.seqFetch, this.options = {
+              checkSequenceMD5: !1 !== e.checkSequenceMD5,
+              cacheSize: void 0 !== e.cacheSize ? e.cacheSize : 2e4
+            }, this.featureCache = new d({
+              maxSize: this.options.cacheSize
+            });
+          }
+
+          var r, n, i, o, p, m, E, k, C, T;
+          return (0, c.default)(t, [{
+            key: "toString",
+            value: function () {
+              return this.file.filename ? this.file.filename : this.file.url ? this.file.url : "(cram file)";
+            }
+          }, {
+            key: "read",
+            value: function (t, e, r, n) {
+              return this.file.read(t, e, r, n);
+            }
+          }, {
+            key: "stat",
+            value: function () {
+              return this.file.stat();
+            }
+          }, {
+            key: "getDefinition",
+            value: (T = (0, u.default)(s.default.mark(function t() {
+              var r, n;
+              return s.default.wrap(function (t) {
+                for (;;) switch (t.prev = t.next) {
+                  case 0:
+                    return r = e.allocUnsafe(b.maxLength), t.next = 3, this.file.read(r, 0, b.maxLength, 0);
+
+                  case 3:
+                    if (2 === (n = b.parser.parse(r).result).majorVersion || 3 === n.majorVersion) {
+                      t.next = 6;
+                      break;
+                    }
+
+                    throw new g("CRAM version ".concat(n.majorVersion, " not supported"));
+
+                  case 6:
+                    return t.abrupt("return", n);
+
+                  case 7:
+                  case "end":
+                    return t.stop();
+                }
+              }, t, this);
+            })), function () {
+              return T.apply(this, arguments);
+            })
+          }, {
+            key: "getSamHeader",
+            value: (C = (0, u.default)(s.default.mark(function t() {
+              var e, r, n, i, o;
+              return s.default.wrap(function (t) {
+                for (;;) switch (t.prev = t.next) {
+                  case 0:
+                    return t.next = 2, this.getContainerById(0);
+
+                  case 2:
+                    if (e = t.sent) {
+                      t.next = 5;
+                      break;
+                    }
+
+                    throw new v("file contains no containers");
+
+                  case 5:
+                    return t.next = 7, e.getFirstBlock();
+
+                  case 7:
+                    return r = t.sent, n = r.content, i = n.readInt32LE(0), o = n.toString("utf8", 4, 4 + i), this.header = o, t.abrupt("return", A(o));
+
+                  case 14:
+                  case "end":
+                    return t.stop();
+                }
+              }, t, this);
+            })), function () {
+              return C.apply(this, arguments);
+            })
+          }, {
+            key: "getHeaderText",
+            value: (k = (0, u.default)(s.default.mark(function t() {
+              return s.default.wrap(function (t) {
+                for (;;) switch (t.prev = t.next) {
+                  case 0:
+                    return t.next = 2, this.getSamHeader();
+
+                  case 2:
+                    return t.abrupt("return", this.header);
+
+                  case 3:
+                  case "end":
+                    return t.stop();
+                }
+              }, t, this);
+            })), function () {
+              return k.apply(this, arguments);
+            })
+          }, {
+            key: "getSectionParsers",
+            value: (E = (0, u.default)(s.default.mark(function t() {
+              var e, r;
+              return s.default.wrap(function (t) {
+                for (;;) switch (t.prev = t.next) {
+                  case 0:
+                    return t.next = 2, this.getDefinition();
+
+                  case 2:
+                    return e = t.sent, r = e.majorVersion, t.abrupt("return", _(r));
+
+                  case 5:
+                  case "end":
+                    return t.stop();
+                }
+              }, t, this);
+            })), function () {
+              return E.apply(this, arguments);
+            })
+          }, {
+            key: "getContainerById",
+            value: (m = (0, u.default)(s.default.mark(function t(e) {
+              var r, n, i, o, a, u, f, c, l, h;
+              return s.default.wrap(function (t) {
+                for (;;) switch (t.prev = t.next) {
+                  case 0:
+                    return t.next = 2, this.getSectionParsers();
+
+                  case 2:
+                    return r = t.sent, n = r.cramFileDefinition.maxLength, t.next = 6, this.file.stat();
+
+                  case 6:
+                    i = t.sent, o = i.size, a = r.cramContainerHeader1, f = 0;
+
+                  case 10:
+                    if (!(f <= e)) {
+                      t.next = 36;
+                      break;
+                    }
+
+                    if (!(n + a.maxLength + 8 >= o)) {
+                      t.next = 13;
+                      break;
+                    }
+
+                    return t.abrupt("return", void 0);
+
+                  case 13:
+                    return u = this.getContainerAtPosition(n), t.next = 16, u.getHeader();
+
+                  case 16:
+                    if (c = t.sent) {
+                      t.next = 19;
+                      break;
+                    }
+
+                    throw new v("container ".concat(e, " not found in file"));
+
+                  case 19:
+                    if (0 !== f) {
+                      t.next = 32;
+                      break;
+                    }
+
+                    n = c._endPosition, l = 0;
+
+                  case 22:
+                    if (!(l < c.numBlocks)) {
+                      t.next = 30;
+                      break;
+                    }
+
+                    return t.next = 25, this.readBlock(n);
+
+                  case 25:
+                    h = t.sent, n = h._endPosition;
+
+                  case 27:
+                    l += 1, t.next = 22;
+                    break;
+
+                  case 30:
+                    t.next = 33;
+                    break;
+
+                  case 32:
+                    n += c._size + c.length;
+
+                  case 33:
+                    f += 1, t.next = 10;
+                    break;
+
+                  case 36:
+                    return t.abrupt("return", u);
+
+                  case 37:
+                  case "end":
+                    return t.stop();
+                }
+              }, t, this);
+            })), function (t) {
+              return m.apply(this, arguments);
+            })
+          }, {
+            key: "checkCrc32",
+            value: (p = (0, u.default)(s.default.mark(function t(r, n, i, o) {
+              var u, f, c, l;
+              return s.default.wrap(function (t) {
+                for (;;) switch (t.prev = t.next) {
+                  case 0:
+                    return u = e.allocUnsafe(n), t.next = 3, this.file.read(u, 0, n, r);
+
+                  case 3:
+                    if ((f = h.unsigned(u)) === i) {
+                      t.next = 6;
+                      break;
+                    }
+
+                    throw new v((0, a.default)(c = (0, a.default)(l = "crc mismatch in ".concat(o, ": recorded CRC32 = ")).call(l, i, ", but calculated CRC32 = ")).call(c, f));
+
+                  case 6:
+                  case "end":
+                    return t.stop();
+                }
+              }, t, this);
+            })), function (t, e, r, n) {
+              return p.apply(this, arguments);
+            })
+          }, {
+            key: "containerCount",
+            value: (o = (0, u.default)(s.default.mark(function t() {
+              var e, r, n, i, o, a, u, f, c;
+              return s.default.wrap(function (t) {
+                for (;;) switch (t.prev = t.next) {
+                  case 0:
+                    return t.next = 2, this.getSectionParsers();
+
+                  case 2:
+                    return e = t.sent, t.next = 5, this.file.stat();
+
+                  case 5:
+                    r = t.sent, n = r.size, i = e.cramContainerHeader1, o = 0, a = e.cramFileDefinition.maxLength;
+
+                  case 10:
+                    if (!(a + i.maxLength + 8 < n)) {
+                      t.next = 33;
+                      break;
+                    }
+
+                    return t.next = 13, this.getContainerAtPosition(a).getHeader();
+
+                  case 13:
+                    if (u = t.sent) {
+                      t.next = 16;
+                      break;
+                    }
+
+                    return t.abrupt("break", 33);
+
+                  case 16:
+                    if (0 !== o) {
+                      t.next = 29;
+                      break;
+                    }
+
+                    a = u._endPosition, f = 0;
+
+                  case 19:
+                    if (!(f < u.numBlocks)) {
+                      t.next = 27;
+                      break;
+                    }
+
+                    return t.next = 22, this.readBlock(a);
+
+                  case 22:
+                    c = t.sent, a = c._endPosition;
+
+                  case 24:
+                    f += 1, t.next = 19;
+                    break;
+
+                  case 27:
+                    t.next = 30;
+                    break;
+
+                  case 29:
+                    a += u._size + u.length;
+
+                  case 30:
+                    o += 1, t.next = 10;
+                    break;
+
+                  case 33:
+                    return t.abrupt("return", o);
+
+                  case 34:
+                  case "end":
+                    return t.stop();
+                }
+              }, t, this);
+            })), function () {
+              return o.apply(this, arguments);
+            })
+          }, {
+            key: "getContainerAtPosition",
+            value: function (t) {
+              return new w(this, t);
+            }
+          }, {
+            key: "readBlockHeader",
+            value: (i = (0, u.default)(s.default.mark(function t(r) {
+              var n, i, o, a, u;
+              return s.default.wrap(function (t) {
+                for (;;) switch (t.prev = t.next) {
+                  case 0:
+                    return t.next = 2, this.getSectionParsers();
+
+                  case 2:
+                    return n = t.sent, i = n.cramBlockHeader, t.next = 6, this.file.stat();
+
+                  case 6:
+                    if (o = t.sent, a = o.size, !(r + i.maxLength >= a)) {
+                      t.next = 10;
+                      break;
+                    }
+
+                    return t.abrupt("return", void 0);
+
+                  case 10:
+                    return u = e.allocUnsafe(i.maxLength), t.next = 13, this.file.read(u, 0, i.maxLength, r);
+
+                  case 13:
+                    return t.abrupt("return", S(u, i.parser, 0, r));
+
+                  case 14:
+                  case "end":
+                    return t.stop();
+                }
+              }, t, this);
+            })), function (t) {
+              return i.apply(this, arguments);
+            })
+          }, {
+            key: "_parseSection",
+            value: (n = (0, u.default)(s.default.mark(function t(r, n) {
+              var i,
+                  o,
+                  u,
+                  f,
+                  c,
+                  l,
+                  h,
+                  d = arguments;
+              return s.default.wrap(function (t) {
+                for (;;) switch (t.prev = t.next) {
+                  case 0:
+                    if (o = d.length > 2 && void 0 !== d[2] ? d[2] : r.maxLength, !(u = d.length > 3 ? d[3] : void 0)) {
+                      t.next = 6;
+                      break;
+                    }
+
+                    f = u, t.next = 15;
+                    break;
+
+                  case 6:
+                    return t.next = 8, this.file.stat();
+
+                  case 8:
+                    if (c = t.sent, l = c.size, !(n + o >= l)) {
+                      t.next = 12;
+                      break;
+                    }
+
+                    return t.abrupt("return", void 0);
+
+                  case 12:
+                    return f = e.allocUnsafe(o), t.next = 15, this.file.read(f, 0, o, n);
+
+                  case 15:
+                    if ((h = S(f, r.parser, 0, n))._size === o) {
+                      t.next = 18;
+                      break;
+                    }
+
+                    throw new v((0, a.default)(i = "section read error: requested size ".concat(o, " does not equal parsed size ")).call(i, h._size));
+
+                  case 18:
+                    return t.abrupt("return", h);
+
+                  case 19:
+                  case "end":
+                    return t.stop();
+                }
+              }, t, this);
+            })), function (t, e) {
+              return n.apply(this, arguments);
+            })
+          }, {
+            key: "_uncompress",
+            value: function (t, e, r) {
+              if ("gzip" === t) {
+                l.gunzipSync(e).copy(r);
+              } else {
+                if ("rans" !== t) throw new g("".concat(t, " decompression not yet implemented"));
+                y.uncompress(e, r);
+              }
+            }
+          }, {
+            key: "readBlock",
+            value: (r = (0, u.default)(s.default.mark(function t(r) {
+              var n, i, o, a, u, f, c, l;
+              return s.default.wrap(function (t) {
+                for (;;) switch (t.prev = t.next) {
+                  case 0:
+                    return t.next = 2, this.getDefinition();
+
+                  case 2:
+                    return n = t.sent, i = n.majorVersion, t.next = 6, this.getSectionParsers();
+
+                  case 6:
+                    return o = t.sent, t.next = 9, this.readBlockHeader(r);
+
+                  case 9:
+                    if (a = t.sent, u = a._endPosition, a.contentPosition = a._endPosition, f = e.allocUnsafe(a.uncompressedSize), "raw" === a.compressionMethod) {
+                      t.next = 20;
+                      break;
+                    }
+
+                    return c = e.allocUnsafe(a.compressedSize), t.next = 17, this.read(c, 0, a.compressedSize, u);
+
+                  case 17:
+                    this._uncompress(a.compressionMethod, c, f), t.next = 22;
+                    break;
+
+                  case 20:
+                    return t.next = 22, this.read(f, 0, a.uncompressedSize, u);
+
+                  case 22:
+                    if (a.content = f, !(i >= 3)) {
+                      t.next = 35;
+                      break;
+                    }
+
+                    return t.next = 26, this._parseSection(o.cramBlockCrc32, u + a.compressedSize);
+
+                  case 26:
+                    if (l = t.sent, a.crc32 = l.crc32, !this.validateChecksums) {
+                      t.next = 31;
+                      break;
+                    }
+
+                    return t.next = 31, this.checkCrc32(r, a._size + a.compressedSize, a.crc32, "block data");
+
+                  case 31:
+                    a._endPosition = l._endPosition, a._size = a.compressedSize + o.cramBlockCrc32.maxLength, t.next = 37;
+                    break;
+
+                  case 35:
+                    a._endPosition = u + a.compressedSize, a._size = a.compressedSize;
+
+                  case 37:
+                    return t.abrupt("return", a);
+
+                  case 38:
+                  case "end":
+                    return t.stop();
+                }
+              }, t, this);
+            })), function (t) {
+              return r.apply(this, arguments);
+            })
+          }]), t;
+        }();
+
+        (0, o.default)(n = "getDefinition getSectionParsers getSamHeader".split(" ")).call(n, function (t) {
+          return k(C, t);
+        }), t.exports = C;
+      }).call(this, r(19).Buffer);
+    }, function (t, e, r) {
+
+      e.byteLength = function (t) {
+        var e = f(t),
+            r = e[0],
+            n = e[1];
+        return 3 * (r + n) / 4 - n;
+      }, e.toByteArray = function (t) {
+        var e,
+            r,
+            n = f(t),
+            a = n[0],
+            s = n[1],
+            u = new o(function (t, e, r) {
+          return 3 * (e + r) / 4 - r;
+        }(0, a, s)),
+            c = 0,
+            l = s > 0 ? a - 4 : a;
+
+        for (r = 0; r < l; r += 4) e = i[t.charCodeAt(r)] << 18 | i[t.charCodeAt(r + 1)] << 12 | i[t.charCodeAt(r + 2)] << 6 | i[t.charCodeAt(r + 3)], u[c++] = e >> 16 & 255, u[c++] = e >> 8 & 255, u[c++] = 255 & e;
+
+        2 === s && (e = i[t.charCodeAt(r)] << 2 | i[t.charCodeAt(r + 1)] >> 4, u[c++] = 255 & e);
+        1 === s && (e = i[t.charCodeAt(r)] << 10 | i[t.charCodeAt(r + 1)] << 4 | i[t.charCodeAt(r + 2)] >> 2, u[c++] = e >> 8 & 255, u[c++] = 255 & e);
+        return u;
+      }, e.fromByteArray = function (t) {
+        for (var e, r = t.length, i = r % 3, o = [], a = 0, s = r - i; a < s; a += 16383) o.push(c(t, a, a + 16383 > s ? s : a + 16383));
+
+        1 === i ? (e = t[r - 1], o.push(n[e >> 2] + n[e << 4 & 63] + "==")) : 2 === i && (e = (t[r - 2] << 8) + t[r - 1], o.push(n[e >> 10] + n[e >> 4 & 63] + n[e << 2 & 63] + "="));
+        return o.join("");
+      };
+
+      for (var n = [], i = [], o = "undefined" != typeof Uint8Array ? Uint8Array : Array, a = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/", s = 0, u = a.length; s < u; ++s) n[s] = a[s], i[a.charCodeAt(s)] = s;
+
+      function f(t) {
+        var e = t.length;
+        if (e % 4 > 0) throw new Error("Invalid string. Length must be a multiple of 4");
+        var r = t.indexOf("=");
+        return -1 === r && (r = e), [r, r === e ? 0 : 4 - r % 4];
+      }
+
+      function c(t, e, r) {
+        for (var i, o, a = [], s = e; s < r; s += 3) i = (t[s] << 16 & 16711680) + (t[s + 1] << 8 & 65280) + (255 & t[s + 2]), a.push(n[(o = i) >> 18 & 63] + n[o >> 12 & 63] + n[o >> 6 & 63] + n[63 & o]);
+
+        return a.join("");
+      }
+
+      i["-".charCodeAt(0)] = 62, i["_".charCodeAt(0)] = 63;
+    }, function (t, e) {
+      e.read = function (t, e, r, n, i) {
+        var o,
+            a,
+            s = 8 * i - n - 1,
+            u = (1 << s) - 1,
+            f = u >> 1,
+            c = -7,
+            l = r ? i - 1 : 0,
+            h = r ? -1 : 1,
+            d = t[e + l];
+
+        for (l += h, o = d & (1 << -c) - 1, d >>= -c, c += s; c > 0; o = 256 * o + t[e + l], l += h, c -= 8);
+
+        for (a = o & (1 << -c) - 1, o >>= -c, c += n; c > 0; a = 256 * a + t[e + l], l += h, c -= 8);
+
+        if (0 === o) o = 1 - f;else {
+          if (o === u) return a ? NaN : 1 / 0 * (d ? -1 : 1);
+          a += Math.pow(2, n), o -= f;
+        }
+        return (d ? -1 : 1) * a * Math.pow(2, o - n);
+      }, e.write = function (t, e, r, n, i, o) {
+        var a,
+            s,
+            u,
+            f = 8 * o - i - 1,
+            c = (1 << f) - 1,
+            l = c >> 1,
+            h = 23 === i ? Math.pow(2, -24) - Math.pow(2, -77) : 0,
+            d = n ? 0 : o - 1,
+            p = n ? 1 : -1,
+            g = e < 0 || 0 === e && 1 / e < 0 ? 1 : 0;
+
+        for (e = Math.abs(e), isNaN(e) || e === 1 / 0 ? (s = isNaN(e) ? 1 : 0, a = c) : (a = Math.floor(Math.log(e) / Math.LN2), e * (u = Math.pow(2, -a)) < 1 && (a--, u *= 2), (e += a + l >= 1 ? h / u : h * Math.pow(2, 1 - l)) * u >= 2 && (a++, u /= 2), a + l >= c ? (s = 0, a = c) : a + l >= 1 ? (s = (e * u - 1) * Math.pow(2, i), a += l) : (s = e * Math.pow(2, l - 1) * Math.pow(2, i), a = 0)); i >= 8; t[r + d] = 255 & s, d += p, s /= 256, i -= 8);
+
+        for (a = a << i | s, f += i; f > 0; t[r + d] = 255 & a, d += p, a /= 256, f -= 8);
+
+        t[r + d - p] |= 128 * g;
+      };
+    }, function (t, e, r) {
+      r(41);
+      var n = r(177),
+          i = r(67),
+          o = Array.prototype,
+          a = {
+        DOMTokenList: !0,
+        NodeList: !0
+      };
+
+      t.exports = function (t) {
+        var e = t.forEach;
+        return t === o || t instanceof Array && e === o.forEach || a.hasOwnProperty(i(t)) ? n : e;
+      };
+    }, function (t, e, r) {
+
+      var n = r(28),
+          i = r(78),
+          o = r(35),
+          a = r(42),
+          s = r(80),
+          u = a.set,
+          f = a.getterFor("Array Iterator");
+      t.exports = s(Array, "Array", function (t, e) {
+        u(this, {
+          type: "Array Iterator",
+          target: n(t),
+          index: 0,
+          kind: e
+        });
+      }, function () {
+        var t = f(this),
+            e = t.target,
+            r = t.kind,
+            n = t.index++;
+        return !e || n >= e.length ? (t.target = void 0, {
+          value: void 0,
+          done: !0
+        }) : "keys" == r ? {
+          value: n,
+          done: !1
+        } : "values" == r ? {
+          value: e[n],
+          done: !1
+        } : {
+          value: [n, e[n]],
+          done: !1
+        };
+      }, "values"), o.Arguments = o.Array, i("keys"), i("values"), i("entries");
+    }, function (t, e, r) {
+      var n = r(13),
+          i = r(170),
+          o = n.WeakMap;
+      t.exports = "function" == typeof o && /native code/.test(i.call(o));
+    }, function (t, e, r) {
+      var n = r(61);
+      t.exports = n("native-function-to-string", Function.toString);
+    }, function (t, e, r) {
+      var n = r(13),
+          i = r(20);
+
+      t.exports = function (t, e) {
+        try {
+          i(n, t, e);
+        } catch (r) {
+          n[t] = e;
+        }
+
+        return e;
+      };
+    }, function (t, e, r) {
+
+      var n = r(108).IteratorPrototype,
+          i = r(44),
+          o = r(43),
+          a = r(36),
+          s = r(35),
+          u = function () {
+        return this;
+      };
+
+      t.exports = function (t, e, r) {
+        var f = e + " Iterator";
+        return t.prototype = i(n, {
+          next: o(1, r)
+        }), a(t, f, !1, !0), s[f] = u, t;
+      };
+    }, function (t, e, r) {
+      var n = r(17),
+          i = r(21),
+          o = r(2),
+          a = r(51);
+      t.exports = n ? Object.defineProperties : function (t, e) {
+        o(t);
+
+        for (var r, n = a(e), s = n.length, u = 0; s > u;) i.f(t, r = n[u++], e[r]);
+
+        return t;
+      };
+    }, function (t, e, r) {
+
+      var n = r(67),
+          i = {};
+      i[r(6)("toStringTag")] = "z", t.exports = "[object z]" !== String(i) ? function () {
+        return "[object " + n(this) + "]";
+      } : i.toString;
+    }, function (t, e, r) {
+      var n = r(14);
+
+      t.exports = function (t) {
+        if (!n(t) && null !== t) throw TypeError("Can't set " + String(t) + " as a prototype");
+        return t;
+      };
+    }, function (t, e) {
+      t.exports = {
+        CSSRuleList: 0,
+        CSSStyleDeclaration: 0,
+        CSSValueList: 0,
+        ClientRectList: 0,
+        DOMRectList: 0,
+        DOMStringList: 0,
+        DOMTokenList: 1,
+        DataTransferItemList: 0,
+        FileList: 0,
+        HTMLAllCollection: 0,
+        HTMLCollection: 0,
+        HTMLFormElement: 0,
+        HTMLSelectElement: 0,
+        MediaList: 0,
+        MimeTypeArray: 0,
+        NamedNodeMap: 0,
+        NodeList: 1,
+        PaintRequestList: 0,
+        Plugin: 0,
+        PluginArray: 0,
+        SVGLengthList: 0,
+        SVGNumberList: 0,
+        SVGPathSegList: 0,
+        SVGPointList: 0,
+        SVGStringList: 0,
+        SVGTransformList: 0,
+        SourceBufferList: 0,
+        StyleSheetList: 0,
+        TextTrackCueList: 0,
+        TextTrackList: 0,
+        TouchList: 0
+      };
+    }, function (t, e, r) {
+      t.exports = r(178);
+    }, function (t, e, r) {
+      r(179);
+      var n = r(18);
+      t.exports = n("Array").forEach;
+    }, function (t, e, r) {
+
+      var n = r(0),
+          i = r(180);
+      n({
+        target: "Array",
+        proto: !0,
+        forced: [].forEach != i
+      }, {
+        forEach: i
+      });
+    }, function (t, e, r) {
+
+      var n = r(45).forEach,
+          i = r(54);
+      t.exports = i("forEach") ? function (t) {
+        return n(this, t, arguments.length > 1 ? arguments[1] : void 0);
+      } : [].forEach;
+    }, function (t, e, r) {
+      t.exports = r(182);
+    }, function (t, e, r) {
+      var n = r(183),
+          i = Array.prototype;
+
+      t.exports = function (t) {
+        var e = t.concat;
+        return t === i || t instanceof Array && e === i.concat ? n : e;
+      };
+    }, function (t, e, r) {
+      r(114);
+      var n = r(18);
+      t.exports = n("Array").concat;
+    }, function (t, e, r) {
+      var n = function (t) {
+
+        var e,
+            r = Object.prototype,
+            n = r.hasOwnProperty,
+            i = "function" == typeof Symbol ? Symbol : {},
+            o = i.iterator || "@@iterator",
+            a = i.asyncIterator || "@@asyncIterator",
+            s = i.toStringTag || "@@toStringTag";
+
+        function u(t, e, r, n) {
+          var i = e && e.prototype instanceof g ? e : g,
+              o = Object.create(i.prototype),
+              a = new C(n || []);
+          return o._invoke = function (t, e, r) {
+            var n = c;
+            return function (i, o) {
+              if (n === h) throw new Error("Generator is already running");
+
+              if (n === d) {
+                if ("throw" === i) throw o;
+                return R();
+              }
+
+              for (r.method = i, r.arg = o;;) {
+                var a = r.delegate;
+
+                if (a) {
+                  var s = S(a, r);
+
+                  if (s) {
+                    if (s === p) continue;
+                    return s;
+                  }
+                }
+
+                if ("next" === r.method) r.sent = r._sent = r.arg;else if ("throw" === r.method) {
+                  if (n === c) throw n = d, r.arg;
+                  r.dispatchException(r.arg);
+                } else "return" === r.method && r.abrupt("return", r.arg);
+                n = h;
+                var u = f(t, e, r);
+
+                if ("normal" === u.type) {
+                  if (n = r.done ? d : l, u.arg === p) continue;
+                  return {
+                    value: u.arg,
+                    done: r.done
+                  };
+                }
+
+                "throw" === u.type && (n = d, r.method = "throw", r.arg = u.arg);
+              }
+            };
+          }(t, r, a), o;
+        }
+
+        function f(t, e, r) {
+          try {
+            return {
+              type: "normal",
+              arg: t.call(e, r)
+            };
+          } catch (t) {
+            return {
+              type: "throw",
+              arg: t
+            };
+          }
+        }
+
+        t.wrap = u;
+        var c = "suspendedStart",
+            l = "suspendedYield",
+            h = "executing",
+            d = "completed",
+            p = {};
+
+        function g() {}
+
+        function v() {}
+
+        function y() {}
+
+        var m = {};
+
+        m[o] = function () {
+          return this;
+        };
+
+        var b = Object.getPrototypeOf,
+            _ = b && b(b(T([])));
+
+        _ && _ !== r && n.call(_, o) && (m = _);
+        var w = y.prototype = g.prototype = Object.create(m);
+
+        function x(t) {
+          ["next", "throw", "return"].forEach(function (e) {
+            t[e] = function (t) {
+              return this._invoke(e, t);
+            };
+          });
+        }
+
+        function E(t, e) {
+          var r;
+
+          this._invoke = function (i, o) {
+            function a() {
+              return new e(function (r, a) {
+                !function r(i, o, a, s) {
+                  var u = f(t[i], t, o);
+
+                  if ("throw" !== u.type) {
+                    var c = u.arg,
+                        l = c.value;
+                    return l && "object" == typeof l && n.call(l, "__await") ? e.resolve(l.__await).then(function (t) {
+                      r("next", t, a, s);
+                    }, function (t) {
+                      r("throw", t, a, s);
+                    }) : e.resolve(l).then(function (t) {
+                      c.value = t, a(c);
+                    }, function (t) {
+                      return r("throw", t, a, s);
+                    });
+                  }
+
+                  s(u.arg);
+                }(i, o, r, a);
+              });
+            }
+
+            return r = r ? r.then(a, a) : a();
+          };
+        }
+
+        function S(t, r) {
+          var n = t.iterator[r.method];
+
+          if (n === e) {
+            if (r.delegate = null, "throw" === r.method) {
+              if (t.iterator.return && (r.method = "return", r.arg = e, S(t, r), "throw" === r.method)) return p;
+              r.method = "throw", r.arg = new TypeError("The iterator does not provide a 'throw' method");
+            }
+
+            return p;
+          }
+
+          var i = f(n, t.iterator, r.arg);
+          if ("throw" === i.type) return r.method = "throw", r.arg = i.arg, r.delegate = null, p;
+          var o = i.arg;
+          return o ? o.done ? (r[t.resultName] = o.value, r.next = t.nextLoc, "return" !== r.method && (r.method = "next", r.arg = e), r.delegate = null, p) : o : (r.method = "throw", r.arg = new TypeError("iterator result is not an object"), r.delegate = null, p);
+        }
+
+        function k(t) {
+          var e = {
+            tryLoc: t[0]
+          };
+          1 in t && (e.catchLoc = t[1]), 2 in t && (e.finallyLoc = t[2], e.afterLoc = t[3]), this.tryEntries.push(e);
+        }
+
+        function A(t) {
+          var e = t.completion || {};
+          e.type = "normal", delete e.arg, t.completion = e;
+        }
+
+        function C(t) {
+          this.tryEntries = [{
+            tryLoc: "root"
+          }], t.forEach(k, this), this.reset(!0);
+        }
+
+        function T(t) {
+          if (t) {
+            var r = t[o];
+            if (r) return r.call(t);
+            if ("function" == typeof t.next) return t;
+
+            if (!isNaN(t.length)) {
+              var i = -1,
+                  a = function r() {
+                for (; ++i < t.length;) if (n.call(t, i)) return r.value = t[i], r.done = !1, r;
+
+                return r.value = e, r.done = !0, r;
+              };
+
+              return a.next = a;
+            }
+          }
+
+          return {
+            next: R
+          };
+        }
+
+        function R() {
+          return {
+            value: e,
+            done: !0
+          };
+        }
+
+        return v.prototype = w.constructor = y, y.constructor = v, y[s] = v.displayName = "GeneratorFunction", t.isGeneratorFunction = function (t) {
+          var e = "function" == typeof t && t.constructor;
+          return !!e && (e === v || "GeneratorFunction" === (e.displayName || e.name));
+        }, t.mark = function (t) {
+          return Object.setPrototypeOf ? Object.setPrototypeOf(t, y) : (t.__proto__ = y, s in t || (t[s] = "GeneratorFunction")), t.prototype = Object.create(w), t;
+        }, t.awrap = function (t) {
+          return {
+            __await: t
+          };
+        }, x(E.prototype), E.prototype[a] = function () {
+          return this;
+        }, t.AsyncIterator = E, t.async = function (e, r, n, i, o) {
+          void 0 === o && (o = Promise);
+          var a = new E(u(e, r, n, i), o);
+          return t.isGeneratorFunction(r) ? a : a.next().then(function (t) {
+            return t.done ? t.value : a.next();
+          });
+        }, x(w), w[s] = "Generator", w[o] = function () {
+          return this;
+        }, w.toString = function () {
+          return "[object Generator]";
+        }, t.keys = function (t) {
+          var e = [];
+
+          for (var r in t) e.push(r);
+
+          return e.reverse(), function r() {
+            for (; e.length;) {
+              var n = e.pop();
+              if (n in t) return r.value = n, r.done = !1, r;
+            }
+
+            return r.done = !0, r;
+          };
+        }, t.values = T, C.prototype = {
+          constructor: C,
+          reset: function (t) {
+            if (this.prev = 0, this.next = 0, this.sent = this._sent = e, this.done = !1, this.delegate = null, this.method = "next", this.arg = e, this.tryEntries.forEach(A), !t) for (var r in this) "t" === r.charAt(0) && n.call(this, r) && !isNaN(+r.slice(1)) && (this[r] = e);
+          },
+          stop: function () {
+            this.done = !0;
+            var t = this.tryEntries[0].completion;
+            if ("throw" === t.type) throw t.arg;
+            return this.rval;
+          },
+          dispatchException: function (t) {
+            if (this.done) throw t;
+            var r = this;
+
+            function i(n, i) {
+              return s.type = "throw", s.arg = t, r.next = n, i && (r.method = "next", r.arg = e), !!i;
+            }
+
+            for (var o = this.tryEntries.length - 1; o >= 0; --o) {
+              var a = this.tryEntries[o],
+                  s = a.completion;
+              if ("root" === a.tryLoc) return i("end");
+
+              if (a.tryLoc <= this.prev) {
+                var u = n.call(a, "catchLoc"),
+                    f = n.call(a, "finallyLoc");
+
+                if (u && f) {
+                  if (this.prev < a.catchLoc) return i(a.catchLoc, !0);
+                  if (this.prev < a.finallyLoc) return i(a.finallyLoc);
+                } else if (u) {
+                  if (this.prev < a.catchLoc) return i(a.catchLoc, !0);
+                } else {
+                  if (!f) throw new Error("try statement without catch or finally");
+                  if (this.prev < a.finallyLoc) return i(a.finallyLoc);
+                }
+              }
+            }
+          },
+          abrupt: function (t, e) {
+            for (var r = this.tryEntries.length - 1; r >= 0; --r) {
+              var i = this.tryEntries[r];
+
+              if (i.tryLoc <= this.prev && n.call(i, "finallyLoc") && this.prev < i.finallyLoc) {
+                var o = i;
+                break;
+              }
+            }
+
+            o && ("break" === t || "continue" === t) && o.tryLoc <= e && e <= o.finallyLoc && (o = null);
+            var a = o ? o.completion : {};
+            return a.type = t, a.arg = e, o ? (this.method = "next", this.next = o.finallyLoc, p) : this.complete(a);
+          },
+          complete: function (t, e) {
+            if ("throw" === t.type) throw t.arg;
+            return "break" === t.type || "continue" === t.type ? this.next = t.arg : "return" === t.type ? (this.rval = this.arg = t.arg, this.method = "return", this.next = "end") : "normal" === t.type && e && (this.next = e), p;
+          },
+          finish: function (t) {
+            for (var e = this.tryEntries.length - 1; e >= 0; --e) {
+              var r = this.tryEntries[e];
+              if (r.finallyLoc === t) return this.complete(r.completion, r.afterLoc), A(r), p;
+            }
+          },
+          catch: function (t) {
+            for (var e = this.tryEntries.length - 1; e >= 0; --e) {
+              var r = this.tryEntries[e];
+
+              if (r.tryLoc === t) {
+                var n = r.completion;
+
+                if ("throw" === n.type) {
+                  var i = n.arg;
+                  A(r);
+                }
+
+                return i;
+              }
+            }
+
+            throw new Error("illegal catch attempt");
+          },
+          delegateYield: function (t, r, n) {
+            return this.delegate = {
+              iterator: T(t),
+              resultName: r,
+              nextLoc: n
+            }, "next" === this.method && (this.arg = e), p;
+          }
+        }, t;
+      }(t.exports);
+
+      try {
+        regeneratorRuntime = n;
+      } catch (t) {
+        Function("r", "regeneratorRuntime = r")(n);
+      }
+    }, function (t, e, r) {
+      t.exports = r(186);
+    }, function (t, e, r) {
+      t.exports = r(115), r(192), r(193), r(194), r(195);
+    }, function (t, e, r) {
+      var n = r(83),
+          i = r(49),
+          o = function (t) {
+        return function (e, r) {
+          var o,
+              a,
+              s = String(i(e)),
+              u = n(r),
+              f = s.length;
+          return u < 0 || u >= f ? t ? "" : void 0 : (o = s.charCodeAt(u)) < 55296 || o > 56319 || u + 1 === f || (a = s.charCodeAt(u + 1)) < 56320 || a > 57343 ? t ? s.charAt(u) : o : t ? s.slice(u, u + 2) : a - 56320 + (o - 55296 << 10) + 65536;
+        };
+      };
+
+      t.exports = {
+        codeAt: o(!1),
+        charAt: o(!0)
+      };
+    }, function (t, e, r) {
+
+      var n,
+          i,
+          o,
+          a,
+          s = r(0),
+          u = r(4),
+          f = r(13),
+          c = r(3),
+          l = r(116),
+          h = r(52),
+          d = r(117),
+          p = r(36),
+          g = r(118),
+          v = r(14),
+          y = r(5),
+          m = r(89),
+          b = r(34),
+          _ = r(8),
+          w = r(121),
+          x = r(55),
+          E = r(122).set,
+          S = r(189),
+          k = r(124),
+          A = r(190),
+          C = r(56),
+          T = r(69),
+          R = r(123),
+          O = r(42),
+          I = r(107),
+          L = r(6)("species"),
+          B = "Promise",
+          P = O.get,
+          F = O.set,
+          N = O.getterFor(B),
+          M = l,
+          j = f.TypeError,
+          z = f.document,
+          U = f.process,
+          D = f.fetch,
+          q = U && U.versions,
+          Z = q && q.v8 || "",
+          H = C.f,
+          V = H,
+          G = "process" == b(U),
+          Y = !!(z && z.createEvent && f.dispatchEvent),
+          W = I(B, function () {
+        var t = M.resolve(1),
+            e = function () {},
+            r = (t.constructor = {})[L] = function (t) {
+          t(e, e);
+        };
+
+        return !((G || "function" == typeof PromiseRejectionEvent) && (!u || t.finally) && t.then(e) instanceof r && 0 !== Z.indexOf("6.6") && -1 === R.indexOf("Chrome/66"));
+      }),
+          K = W || !w(function (t) {
+        M.all(t).catch(function () {});
+      }),
+          Q = function (t) {
+        var e;
+        return !(!v(t) || "function" != typeof (e = t.then)) && e;
+      },
+          X = function (t, e, r) {
+        if (!e.notified) {
+          e.notified = !0;
+          var n = e.reactions;
+          S(function () {
+            for (var i = e.value, o = 1 == e.state, a = 0; n.length > a;) {
+              var s,
+                  u,
+                  f,
+                  c = n[a++],
+                  l = o ? c.ok : c.fail,
+                  h = c.resolve,
+                  d = c.reject,
+                  p = c.domain;
+
+              try {
+                l ? (o || (2 === e.rejection && et(t, e), e.rejection = 1), !0 === l ? s = i : (p && p.enter(), s = l(i), p && (p.exit(), f = !0)), s === c.promise ? d(j("Promise-chain cycle")) : (u = Q(s)) ? u.call(s, h, d) : h(s)) : d(i);
+              } catch (t) {
+                p && !f && p.exit(), d(t);
+              }
+            }
+
+            e.reactions = [], e.notified = !1, r && !e.rejection && J(t, e);
+          });
+        }
+      },
+          $ = function (t, e, r) {
+        var n, i;
+        Y ? ((n = z.createEvent("Event")).promise = e, n.reason = r, n.initEvent(t, !1, !0), f.dispatchEvent(n)) : n = {
+          promise: e,
+          reason: r
+        }, (i = f["on" + t]) ? i(n) : "unhandledrejection" === t && A("Unhandled promise rejection", r);
+      },
+          J = function (t, e) {
+        E.call(f, function () {
+          var r,
+              n = e.value;
+          if (tt(e) && (r = T(function () {
+            G ? U.emit("unhandledRejection", n, t) : $("unhandledrejection", t, n);
+          }), e.rejection = G || tt(e) ? 2 : 1, r.error)) throw r.value;
+        });
+      },
+          tt = function (t) {
+        return 1 !== t.rejection && !t.parent;
+      },
+          et = function (t, e) {
+        E.call(f, function () {
+          G ? U.emit("rejectionHandled", t) : $("rejectionhandled", t, e.value);
+        });
+      },
+          rt = function (t, e, r, n) {
+        return function (i) {
+          t(e, r, i, n);
+        };
+      },
+          nt = function (t, e, r, n) {
+        e.done || (e.done = !0, n && (e = n), e.value = r, e.state = 2, X(t, e, !0));
+      },
+          it = function (t, e, r, n) {
+        if (!e.done) {
+          e.done = !0, n && (e = n);
+
+          try {
+            if (t === r) throw j("Promise can't be resolved itself");
+            var i = Q(r);
+            i ? S(function () {
+              var n = {
+                done: !1
+              };
+
+              try {
+                i.call(r, rt(it, t, n, e), rt(nt, t, n, e));
+              } catch (r) {
+                nt(t, n, r, e);
+              }
+            }) : (e.value = r, e.state = 1, X(t, e, !1));
+          } catch (r) {
+            nt(t, {
+              done: !1
+            }, r, e);
+          }
+        }
+      };
+
+      W && (M = function (t) {
+        m(this, M, B), y(t), n.call(this);
+        var e = P(this);
+
+        try {
+          t(rt(it, this, e), rt(nt, this, e));
+        } catch (t) {
+          nt(this, e, t);
+        }
+      }, (n = function (t) {
+        F(this, {
+          type: B,
+          done: !1,
+          notified: !1,
+          parent: !1,
+          reactions: [],
+          rejection: !1,
+          state: 0,
+          value: void 0
+        });
+      }).prototype = d(M.prototype, {
+        then: function (t, e) {
+          var r = N(this),
+              n = H(x(this, M));
+          return n.ok = "function" != typeof t || t, n.fail = "function" == typeof e && e, n.domain = G ? U.domain : void 0, r.parent = !0, r.reactions.push(n), 0 != r.state && X(this, r, !1), n.promise;
+        },
+        catch: function (t) {
+          return this.then(void 0, t);
+        }
+      }), i = function () {
+        var t = new n(),
+            e = P(t);
+        this.promise = t, this.resolve = rt(it, t, e), this.reject = rt(nt, t, e);
+      }, C.f = H = function (t) {
+        return t === M || t === o ? new i(t) : V(t);
+      }, u || "function" != typeof l || (a = l.prototype.then, h(l.prototype, "then", function (t, e) {
+        var r = this;
+        return new M(function (t, e) {
+          a.call(r, t, e);
+        }).then(t, e);
+      }), "function" == typeof D && s({
+        global: !0,
+        enumerable: !0,
+        forced: !0
+      }, {
+        fetch: function (t) {
+          return k(M, D.apply(f, arguments));
+        }
+      }))), s({
+        global: !0,
+        wrap: !0,
+        forced: W
+      }, {
+        Promise: M
+      }), p(M, B, !1, !0), g(B), o = c.Promise, s({
+        target: B,
+        stat: !0,
+        forced: W
+      }, {
+        reject: function (t) {
+          var e = H(this);
+          return e.reject.call(void 0, t), e.promise;
+        }
+      }), s({
+        target: B,
+        stat: !0,
+        forced: u || W
+      }, {
+        resolve: function (t) {
+          return k(u && this === o ? M : this, t);
+        }
+      }), s({
+        target: B,
+        stat: !0,
+        forced: K
+      }, {
+        all: function (t) {
+          var e = this,
+              r = H(e),
+              n = r.resolve,
+              i = r.reject,
+              o = T(function () {
+            var r = y(e.resolve),
+                o = [],
+                a = 0,
+                s = 1;
+            _(t, function (t) {
+              var u = a++,
+                  f = !1;
+              o.push(void 0), s++, r.call(e, t).then(function (t) {
+                f || (f = !0, o[u] = t, --s || n(o));
+              }, i);
+            }), --s || n(o);
+          });
+          return o.error && i(o.value), r.promise;
+        },
+        race: function (t) {
+          var e = this,
+              r = H(e),
+              n = r.reject,
+              i = T(function () {
+            var i = y(e.resolve);
+
+            _(t, function (t) {
+              i.call(e, t).then(r.resolve, n);
+            });
+          });
+          return i.error && n(i.value), r.promise;
+        }
+      });
+    }, function (t, e, r) {
+      var n,
+          i,
+          o,
+          a,
+          s,
+          u,
+          f,
+          c,
+          l = r(13),
+          h = r(81).f,
+          d = r(34),
+          p = r(122).set,
+          g = r(123),
+          v = l.MutationObserver || l.WebKitMutationObserver,
+          y = l.process,
+          m = l.Promise,
+          b = "process" == d(y),
+          _ = h(l, "queueMicrotask"),
+          w = _ && _.value;
+
+      w || (n = function () {
+        var t, e;
+
+        for (b && (t = y.domain) && t.exit(); i;) {
+          e = i.fn, i = i.next;
+
+          try {
+            e();
+          } catch (t) {
+            throw i ? a() : o = void 0, t;
+          }
+        }
+
+        o = void 0, t && t.enter();
+      }, b ? a = function () {
+        y.nextTick(n);
+      } : v && !/(iphone|ipod|ipad).*applewebkit/i.test(g) ? (s = !0, u = document.createTextNode(""), new v(n).observe(u, {
+        characterData: !0
+      }), a = function () {
+        u.data = s = !s;
+      }) : m && m.resolve ? (f = m.resolve(void 0), c = f.then, a = function () {
+        c.call(f, n);
+      }) : a = function () {
+        p.call(l, n);
+      }), t.exports = w || function (t) {
+        var e = {
+          fn: t,
+          next: void 0
+        };
+        o && (o.next = e), i || (i = e, a()), o = e;
+      };
+    }, function (t, e, r) {
+      var n = r(13);
+
+      t.exports = function (t, e) {
+        var r = n.console;
+        r && r.error && (1 === arguments.length ? r.error(t) : r.error(t, e));
+      };
+    }, function (t, e, r) {
+
+      var n = r(0),
+          i = r(4),
+          o = r(116),
+          a = r(26),
+          s = r(55),
+          u = r(124),
+          f = r(52);
+      n({
+        target: "Promise",
+        proto: !0,
+        real: !0
+      }, {
+        finally: function (t) {
+          var e = s(this, a("Promise")),
+              r = "function" == typeof t;
+          return this.then(r ? function (r) {
+            return u(e, t()).then(function () {
+              return r;
+            });
+          } : t, r ? function (r) {
+            return u(e, t()).then(function () {
+              throw r;
+            });
+          } : t);
+        }
+      }), i || "function" != typeof o || o.prototype.finally || f(o.prototype, "finally", a("Promise").prototype.finally);
+    }, function (t, e, r) {
+      var n = r(0),
+          i = r(66),
+          o = r(86),
+          a = r(44),
+          s = r(43),
+          u = r(8),
+          f = r(20),
+          c = function (t, e) {
+        var r = this;
+        if (!(r instanceof c)) return new c(t, e);
+        o && (r = o(new Error(e), i(r)));
+        var n = [];
+        return u(t, n.push, n), f(r, "errors", n), void 0 !== e && f(r, "message", String(e)), r;
+      };
+
+      c.prototype = a(Error.prototype, {
+        constructor: s(5, c),
+        name: s(5, "AggregateError")
+      }), n({
+        global: !0
+      }, {
+        AggregateError: c
+      });
+    }, function (t, e, r) {
+      r(125);
+    }, function (t, e, r) {
+
+      var n = r(0),
+          i = r(56),
+          o = r(69);
+      n({
+        target: "Promise",
+        stat: !0
+      }, {
+        try: function (t) {
+          var e = i.f(this),
+              r = o(t);
+          return (r.error ? e.reject : e.resolve)(r.value), e.promise;
+        }
+      });
+    }, function (t, e, r) {
+
+      var n = r(0),
+          i = r(5),
+          o = r(26),
+          a = r(56),
+          s = r(69),
+          u = r(8);
+      n({
+        target: "Promise",
+        stat: !0
+      }, {
+        any: function (t) {
+          var e = this,
+              r = a.f(e),
+              n = r.resolve,
+              f = r.reject,
+              c = s(function () {
+            var r = i(e.resolve),
+                a = [],
+                s = 0,
+                c = 1,
+                l = !1;
+            u(t, function (t) {
+              var i = s++,
+                  u = !1;
+              a.push(void 0), c++, r.call(e, t).then(function (t) {
+                u || l || (l = !0, n(t));
+              }, function (t) {
+                u || l || (u = !0, a[i] = t, --c || f(new (o("AggregateError"))(a, "No one promise resolved")));
+              });
+            }), --c || f(new (o("AggregateError"))(a, "No one promise resolved"));
+          });
+          return c.error && f(c.value), r.promise;
+        }
+      });
+    }, function (t, e, r) {
+      t.exports = r(197);
+    }, function (t, e, r) {
+      t.exports = r(198);
+    }, function (t, e, r) {
+      r(199);
+
+      var n = r(3).Object,
+          i = t.exports = function (t, e, r) {
+        return n.defineProperty(t, e, r);
+      };
+
+      n.defineProperty.sham && (i.sham = !0);
+    }, function (t, e, r) {
+      var n = r(0),
+          i = r(17);
+      n({
+        target: "Object",
+        stat: !0,
+        forced: !i,
+        sham: !i
+      }, {
+        defineProperty: r(21).f
+      });
+    }, function (t, e, r) {
+      t.exports = i;
+      var n = r(91).EventEmitter;
+
+      function i() {
+        n.call(this);
+      }
+
+      r(47)(i, n), i.Readable = r(92), i.Writable = r(208), i.Duplex = r(209), i.Transform = r(210), i.PassThrough = r(211), i.Stream = i, i.prototype.pipe = function (t, e) {
+        var r = this;
+
+        function i(e) {
+          t.writable && !1 === t.write(e) && r.pause && r.pause();
+        }
+
+        function o() {
+          r.readable && r.resume && r.resume();
+        }
+
+        r.on("data", i), t.on("drain", o), t._isStdio || e && !1 === e.end || (r.on("end", s), r.on("close", u));
+        var a = !1;
+
+        function s() {
+          a || (a = !0, t.end());
+        }
+
+        function u() {
+          a || (a = !0, "function" == typeof t.destroy && t.destroy());
+        }
+
+        function f(t) {
+          if (c(), 0 === n.listenerCount(this, "error")) throw t;
+        }
+
+        function c() {
+          r.removeListener("data", i), t.removeListener("drain", o), r.removeListener("end", s), r.removeListener("close", u), r.removeListener("error", f), t.removeListener("error", f), r.removeListener("end", c), r.removeListener("close", c), t.removeListener("close", c);
+        }
+
+        return r.on("error", f), t.on("error", f), r.on("end", c), r.on("close", c), t.on("close", c), t.emit("pipe", r), t;
+      };
+    }, function (t, e) {}, function (t, e, r) {
+
+      var n = r(71).Buffer,
+          i = r(203);
+      t.exports = function () {
+        function t() {
+          !function (t, e) {
+            if (!(t instanceof e)) throw new TypeError("Cannot call a class as a function");
+          }(this, t), this.head = null, this.tail = null, this.length = 0;
+        }
+
+        return t.prototype.push = function (t) {
+          var e = {
+            data: t,
+            next: null
+          };
+          this.length > 0 ? this.tail.next = e : this.head = e, this.tail = e, ++this.length;
+        }, t.prototype.unshift = function (t) {
+          var e = {
+            data: t,
+            next: this.head
+          };
+          0 === this.length && (this.tail = e), this.head = e, ++this.length;
+        }, t.prototype.shift = function () {
+          if (0 !== this.length) {
+            var t = this.head.data;
+            return 1 === this.length ? this.head = this.tail = null : this.head = this.head.next, --this.length, t;
+          }
+        }, t.prototype.clear = function () {
+          this.head = this.tail = null, this.length = 0;
+        }, t.prototype.join = function (t) {
+          if (0 === this.length) return "";
+
+          for (var e = this.head, r = "" + e.data; e = e.next;) r += t + e.data;
+
+          return r;
+        }, t.prototype.concat = function (t) {
+          if (0 === this.length) return n.alloc(0);
+          if (1 === this.length) return this.head.data;
+
+          for (var e, r, i, o = n.allocUnsafe(t >>> 0), a = this.head, s = 0; a;) e = a.data, r = o, i = s, e.copy(r, i), s += a.data.length, a = a.next;
+
+          return o;
+        }, t;
+      }(), i && i.inspect && i.inspect.custom && (t.exports.prototype[i.inspect.custom] = function () {
+        var t = i.inspect({
+          length: this.length
+        });
+        return this.constructor.name + " " + t;
+      });
+    }, function (t, e) {}, function (t, e, r) {
+      (function (t) {
+        var n = void 0 !== t && t || "undefined" != typeof self && self || window,
+            i = Function.prototype.apply;
+
+        function o(t, e) {
+          this._id = t, this._clearFn = e;
+        }
+
+        e.setTimeout = function () {
+          return new o(i.call(setTimeout, n, arguments), clearTimeout);
+        }, e.setInterval = function () {
+          return new o(i.call(setInterval, n, arguments), clearInterval);
+        }, e.clearTimeout = e.clearInterval = function (t) {
+          t && t.close();
+        }, o.prototype.unref = o.prototype.ref = function () {}, o.prototype.close = function () {
+          this._clearFn.call(n, this._id);
+        }, e.enroll = function (t, e) {
+          clearTimeout(t._idleTimeoutId), t._idleTimeout = e;
+        }, e.unenroll = function (t) {
+          clearTimeout(t._idleTimeoutId), t._idleTimeout = -1;
+        }, e._unrefActive = e.active = function (t) {
+          clearTimeout(t._idleTimeoutId);
+          var e = t._idleTimeout;
+          e >= 0 && (t._idleTimeoutId = setTimeout(function () {
+            t._onTimeout && t._onTimeout();
+          }, e));
+        }, r(205), e.setImmediate = "undefined" != typeof self && self.setImmediate || void 0 !== t && t.setImmediate || this && this.setImmediate, e.clearImmediate = "undefined" != typeof self && self.clearImmediate || void 0 !== t && t.clearImmediate || this && this.clearImmediate;
+      }).call(this, r(23));
+    }, function (t, e, r) {
+      (function (t, e) {
+        !function (t, r) {
+
+          if (!t.setImmediate) {
+            var n,
+                i,
+                o,
+                a,
+                s,
+                u = 1,
+                f = {},
+                c = !1,
+                l = t.document,
+                h = Object.getPrototypeOf && Object.getPrototypeOf(t);
+            h = h && h.setTimeout ? h : t, "[object process]" === {}.toString.call(t.process) ? n = function (t) {
+              e.nextTick(function () {
+                p(t);
+              });
+            } : !function () {
+              if (t.postMessage && !t.importScripts) {
+                var e = !0,
+                    r = t.onmessage;
+                return t.onmessage = function () {
+                  e = !1;
+                }, t.postMessage("", "*"), t.onmessage = r, e;
+              }
+            }() ? t.MessageChannel ? ((o = new MessageChannel()).port1.onmessage = function (t) {
+              p(t.data);
+            }, n = function (t) {
+              o.port2.postMessage(t);
+            }) : l && "onreadystatechange" in l.createElement("script") ? (i = l.documentElement, n = function (t) {
+              var e = l.createElement("script");
+              e.onreadystatechange = function () {
+                p(t), e.onreadystatechange = null, i.removeChild(e), e = null;
+              }, i.appendChild(e);
+            }) : n = function (t) {
+              setTimeout(p, 0, t);
+            } : (a = "setImmediate$" + Math.random() + "$", s = function (e) {
+              e.source === t && "string" == typeof e.data && 0 === e.data.indexOf(a) && p(+e.data.slice(a.length));
+            }, t.addEventListener ? t.addEventListener("message", s, !1) : t.attachEvent("onmessage", s), n = function (e) {
+              t.postMessage(a + e, "*");
+            }), h.setImmediate = function (t) {
+              "function" != typeof t && (t = new Function("" + t));
+
+              for (var e = new Array(arguments.length - 1), r = 0; r < e.length; r++) e[r] = arguments[r + 1];
+
+              var i = {
+                callback: t,
+                args: e
+              };
+              return f[u] = i, n(u), u++;
+            }, h.clearImmediate = d;
+          }
+
+          function d(t) {
+            delete f[t];
+          }
+
+          function p(t) {
+            if (c) setTimeout(p, 0, t);else {
+              var e = f[t];
+
+              if (e) {
+                c = !0;
+
+                try {
+                  !function (t) {
+                    var e = t.callback,
+                        n = t.args;
+
+                    switch (n.length) {
+                      case 0:
+                        e();
+                        break;
+
+                      case 1:
+                        e(n[0]);
+                        break;
+
+                      case 2:
+                        e(n[0], n[1]);
+                        break;
+
+                      case 3:
+                        e(n[0], n[1], n[2]);
+                        break;
+
+                      default:
+                        e.apply(r, n);
+                    }
+                  }(e);
+                } finally {
+                  d(t), c = !1;
+                }
+              }
+            }
+          }
+        }("undefined" == typeof self ? void 0 === t ? this : t : self);
+      }).call(this, r(23), r(38));
+    }, function (t, e, r) {
+      (function (e) {
+        function r(t) {
+          try {
+            if (!e.localStorage) return !1;
+          } catch (t) {
+            return !1;
+          }
+
+          var r = e.localStorage[t];
+          return null != r && "true" === String(r).toLowerCase();
+        }
+
+        t.exports = function (t, e) {
+          if (r("noDeprecation")) return t;
+          var n = !1;
+          return function () {
+            if (!n) {
+              if (r("throwDeprecation")) throw new Error(e);
+              r("traceDeprecation") ? console.trace(e) : console.warn(e), n = !0;
+            }
+
+            return t.apply(this, arguments);
+          };
+        };
+      }).call(this, r(23));
+    }, function (t, e, r) {
+
+      t.exports = o;
+      var n = r(131),
+          i = r(57);
+
+      function o(t) {
+        if (!(this instanceof o)) return new o(t);
+        n.call(this, t);
+      }
+
+      i.inherits = r(47), i.inherits(o, n), o.prototype._transform = function (t, e, r) {
+        r(null, t);
+      };
+    }, function (t, e, r) {
+      t.exports = r(93);
+    }, function (t, e, r) {
+      t.exports = r(39);
+    }, function (t, e, r) {
+      t.exports = r(92).Transform;
+    }, function (t, e, r) {
+      t.exports = r(92).PassThrough;
+    }, function (t, e, r) {
+
+      (function (t, n) {
+        var i = r(132),
+            o = r(216),
+            a = r(217),
+            s = r(220),
+            u = r(223);
+
+        for (var f in u) e[f] = u[f];
+
+        e.NONE = 0, e.DEFLATE = 1, e.INFLATE = 2, e.GZIP = 3, e.GUNZIP = 4, e.DEFLATERAW = 5, e.INFLATERAW = 6, e.UNZIP = 7;
+
+        function c(t) {
+          if ("number" != typeof t || t < e.DEFLATE || t > e.UNZIP) throw new TypeError("Bad argument");
+          this.dictionary = null, this.err = 0, this.flush = 0, this.init_done = !1, this.level = 0, this.memLevel = 0, this.mode = t, this.strategy = 0, this.windowBits = 0, this.write_in_progress = !1, this.pending_close = !1, this.gzip_id_bytes_read = 0;
+        }
+
+        c.prototype.close = function () {
+          this.write_in_progress ? this.pending_close = !0 : (this.pending_close = !1, i(this.init_done, "close before init"), i(this.mode <= e.UNZIP), this.mode === e.DEFLATE || this.mode === e.GZIP || this.mode === e.DEFLATERAW ? a.deflateEnd(this.strm) : this.mode !== e.INFLATE && this.mode !== e.GUNZIP && this.mode !== e.INFLATERAW && this.mode !== e.UNZIP || s.inflateEnd(this.strm), this.mode = e.NONE, this.dictionary = null);
+        }, c.prototype.write = function (t, e, r, n, i, o, a) {
+          return this._write(!0, t, e, r, n, i, o, a);
+        }, c.prototype.writeSync = function (t, e, r, n, i, o, a) {
+          return this._write(!1, t, e, r, n, i, o, a);
+        }, c.prototype._write = function (r, o, a, s, u, f, c, l) {
+          if (i.equal(arguments.length, 8), i(this.init_done, "write before init"), i(this.mode !== e.NONE, "already finalized"), i.equal(!1, this.write_in_progress, "write already in progress"), i.equal(!1, this.pending_close, "close is pending"), this.write_in_progress = !0, i.equal(!1, void 0 === o, "must provide flush value"), this.write_in_progress = !0, o !== e.Z_NO_FLUSH && o !== e.Z_PARTIAL_FLUSH && o !== e.Z_SYNC_FLUSH && o !== e.Z_FULL_FLUSH && o !== e.Z_FINISH && o !== e.Z_BLOCK) throw new Error("Invalid flush value");
+          if (null == a && (a = t.alloc(0), u = 0, s = 0), this.strm.avail_in = u, this.strm.input = a, this.strm.next_in = s, this.strm.avail_out = l, this.strm.output = f, this.strm.next_out = c, this.flush = o, !r) return this._process(), this._checkError() ? this._afterSync() : void 0;
+          var h = this;
+          return n.nextTick(function () {
+            h._process(), h._after();
+          }), this;
+        }, c.prototype._afterSync = function () {
+          var t = this.strm.avail_out,
+              e = this.strm.avail_in;
+          return this.write_in_progress = !1, [e, t];
+        }, c.prototype._process = function () {
+          var t = null;
+
+          switch (this.mode) {
+            case e.DEFLATE:
+            case e.GZIP:
+            case e.DEFLATERAW:
+              this.err = a.deflate(this.strm, this.flush);
+              break;
+
+            case e.UNZIP:
+              switch (this.strm.avail_in > 0 && (t = this.strm.next_in), this.gzip_id_bytes_read) {
+                case 0:
+                  if (null === t) break;
+
+                  if (31 !== this.strm.input[t]) {
+                    this.mode = e.INFLATE;
+                    break;
+                  }
+
+                  if (this.gzip_id_bytes_read = 1, t++, 1 === this.strm.avail_in) break;
+
+                case 1:
+                  if (null === t) break;
+                  139 === this.strm.input[t] ? (this.gzip_id_bytes_read = 2, this.mode = e.GUNZIP) : this.mode = e.INFLATE;
+                  break;
+
+                default:
+                  throw new Error("invalid number of gzip magic number bytes read");
+              }
+
+            case e.INFLATE:
+            case e.GUNZIP:
+            case e.INFLATERAW:
+              for (this.err = s.inflate(this.strm, this.flush), this.err === e.Z_NEED_DICT && this.dictionary && (this.err = s.inflateSetDictionary(this.strm, this.dictionary), this.err === e.Z_OK ? this.err = s.inflate(this.strm, this.flush) : this.err === e.Z_DATA_ERROR && (this.err = e.Z_NEED_DICT)); this.strm.avail_in > 0 && this.mode === e.GUNZIP && this.err === e.Z_STREAM_END && 0 !== this.strm.next_in[0];) this.reset(), this.err = s.inflate(this.strm, this.flush);
+
+              break;
+
+            default:
+              throw new Error("Unknown mode " + this.mode);
+          }
+        }, c.prototype._checkError = function () {
+          switch (this.err) {
+            case e.Z_OK:
+            case e.Z_BUF_ERROR:
+              if (0 !== this.strm.avail_out && this.flush === e.Z_FINISH) return this._error("unexpected end of file"), !1;
+              break;
+
+            case e.Z_STREAM_END:
+              break;
+
+            case e.Z_NEED_DICT:
+              return null == this.dictionary ? this._error("Missing dictionary") : this._error("Bad dictionary"), !1;
+
+            default:
+              return this._error("Zlib error"), !1;
+          }
+
+          return !0;
+        }, c.prototype._after = function () {
+          if (this._checkError()) {
+            var t = this.strm.avail_out,
+                e = this.strm.avail_in;
+            this.write_in_progress = !1, this.callback(e, t), this.pending_close && this.close();
+          }
+        }, c.prototype._error = function (t) {
+          this.strm.msg && (t = this.strm.msg), this.onerror(t, this.err), this.write_in_progress = !1, this.pending_close && this.close();
+        }, c.prototype.init = function (t, r, n, o, a) {
+          i(4 === arguments.length || 5 === arguments.length, "init(windowBits, level, memLevel, strategy, [dictionary])"), i(t >= 8 && t <= 15, "invalid windowBits"), i(r >= -1 && r <= 9, "invalid compression level"), i(n >= 1 && n <= 9, "invalid memlevel"), i(o === e.Z_FILTERED || o === e.Z_HUFFMAN_ONLY || o === e.Z_RLE || o === e.Z_FIXED || o === e.Z_DEFAULT_STRATEGY, "invalid strategy"), this._init(r, t, n, o, a), this._setDictionary();
+        }, c.prototype.params = function () {
+          throw new Error("deflateParams Not supported");
+        }, c.prototype.reset = function () {
+          this._reset(), this._setDictionary();
+        }, c.prototype._init = function (t, r, n, i, u) {
+          switch (this.level = t, this.windowBits = r, this.memLevel = n, this.strategy = i, this.flush = e.Z_NO_FLUSH, this.err = e.Z_OK, this.mode !== e.GZIP && this.mode !== e.GUNZIP || (this.windowBits += 16), this.mode === e.UNZIP && (this.windowBits += 32), this.mode !== e.DEFLATERAW && this.mode !== e.INFLATERAW || (this.windowBits = -1 * this.windowBits), this.strm = new o(), this.mode) {
+            case e.DEFLATE:
+            case e.GZIP:
+            case e.DEFLATERAW:
+              this.err = a.deflateInit2(this.strm, this.level, e.Z_DEFLATED, this.windowBits, this.memLevel, this.strategy);
+              break;
+
+            case e.INFLATE:
+            case e.GUNZIP:
+            case e.INFLATERAW:
+            case e.UNZIP:
+              this.err = s.inflateInit2(this.strm, this.windowBits);
+              break;
+
+            default:
+              throw new Error("Unknown mode " + this.mode);
+          }
+
+          this.err !== e.Z_OK && this._error("Init error"), this.dictionary = u, this.write_in_progress = !1, this.init_done = !0;
+        }, c.prototype._setDictionary = function () {
+          if (null != this.dictionary) {
+            switch (this.err = e.Z_OK, this.mode) {
+              case e.DEFLATE:
+              case e.DEFLATERAW:
+                this.err = a.deflateSetDictionary(this.strm, this.dictionary);
+            }
+
+            this.err !== e.Z_OK && this._error("Failed to set dictionary");
+          }
+        }, c.prototype._reset = function () {
+          switch (this.err = e.Z_OK, this.mode) {
+            case e.DEFLATE:
+            case e.DEFLATERAW:
+            case e.GZIP:
+              this.err = a.deflateReset(this.strm);
+              break;
+
+            case e.INFLATE:
+            case e.INFLATERAW:
+            case e.GUNZIP:
+              this.err = s.inflateReset(this.strm);
+          }
+
+          this.err !== e.Z_OK && this._error("Failed to reset stream");
+        }, e.Zlib = c;
+      }).call(this, r(19).Buffer, r(38));
+    }, function (t, e, r) {
+      /*
+      object-assign
+      (c) Sindre Sorhus
+      @license MIT
+      */
+
+      var n = Object.getOwnPropertySymbols,
+          i = Object.prototype.hasOwnProperty,
+          o = Object.prototype.propertyIsEnumerable;
+
+      function a(t) {
+        if (null == t) throw new TypeError("Object.assign cannot be called with null or undefined");
+        return Object(t);
+      }
+
+      t.exports = function () {
+        try {
+          if (!Object.assign) return !1;
+          var t = new String("abc");
+          if (t[5] = "de", "5" === Object.getOwnPropertyNames(t)[0]) return !1;
+
+          for (var e = {}, r = 0; r < 10; r++) e["_" + String.fromCharCode(r)] = r;
+
+          if ("0123456789" !== Object.getOwnPropertyNames(e).map(function (t) {
+            return e[t];
+          }).join("")) return !1;
+          var n = {};
+          return "abcdefghijklmnopqrst".split("").forEach(function (t) {
+            n[t] = t;
+          }), "abcdefghijklmnopqrst" === Object.keys(Object.assign({}, n)).join("");
+        } catch (t) {
+          return !1;
+        }
+      }() ? Object.assign : function (t, e) {
+        for (var r, s, u = a(t), f = 1; f < arguments.length; f++) {
+          for (var c in r = Object(arguments[f])) i.call(r, c) && (u[c] = r[c]);
+
+          if (n) {
+            s = n(r);
+
+            for (var l = 0; l < s.length; l++) o.call(r, s[l]) && (u[s[l]] = r[s[l]]);
+          }
+        }
+
+        return u;
+      };
+    }, function (t, e) {
+      t.exports = function (t) {
+        return t && "object" == typeof t && "function" == typeof t.copy && "function" == typeof t.fill && "function" == typeof t.readUInt8;
+      };
+    }, function (t, e) {
+      "function" == typeof Object.create ? t.exports = function (t, e) {
+        t.super_ = e, t.prototype = Object.create(e.prototype, {
+          constructor: {
+            value: t,
+            enumerable: !1,
+            writable: !0,
+            configurable: !0
+          }
+        });
+      } : t.exports = function (t, e) {
+        t.super_ = e;
+
+        var r = function () {};
+
+        r.prototype = e.prototype, t.prototype = new r(), t.prototype.constructor = t;
+      };
+    }, function (t, e, r) {
+
+      t.exports = function () {
+        this.input = null, this.next_in = 0, this.avail_in = 0, this.total_in = 0, this.output = null, this.next_out = 0, this.avail_out = 0, this.total_out = 0, this.msg = "", this.state = null, this.data_type = 2, this.adler = 0;
+      };
+    }, function (t, e, r) {
+
+      var n,
+          i = r(72),
+          o = r(218),
+          a = r(134),
+          s = r(135),
+          u = r(219),
+          f = 0,
+          c = 1,
+          l = 3,
+          h = 4,
+          d = 5,
+          p = 0,
+          g = 1,
+          v = -2,
+          y = -3,
+          m = -5,
+          b = -1,
+          _ = 1,
+          w = 2,
+          x = 3,
+          E = 4,
+          S = 0,
+          k = 2,
+          A = 8,
+          C = 9,
+          T = 15,
+          R = 8,
+          O = 286,
+          I = 30,
+          L = 19,
+          B = 2 * O + 1,
+          P = 15,
+          F = 3,
+          N = 258,
+          M = N + F + 1,
+          j = 32,
+          z = 42,
+          U = 69,
+          D = 73,
+          q = 91,
+          Z = 103,
+          H = 113,
+          V = 666,
+          G = 1,
+          Y = 2,
+          W = 3,
+          K = 4,
+          Q = 3;
+
+      function X(t, e) {
+        return t.msg = u[e], e;
+      }
+
+      function $(t) {
+        return (t << 1) - (t > 4 ? 9 : 0);
+      }
+
+      function J(t) {
+        for (var e = t.length; --e >= 0;) t[e] = 0;
+      }
+
+      function tt(t) {
+        var e = t.state,
+            r = e.pending;
+        r > t.avail_out && (r = t.avail_out), 0 !== r && (i.arraySet(t.output, e.pending_buf, e.pending_out, r, t.next_out), t.next_out += r, e.pending_out += r, t.total_out += r, t.avail_out -= r, e.pending -= r, 0 === e.pending && (e.pending_out = 0));
+      }
+
+      function et(t, e) {
+        o._tr_flush_block(t, t.block_start >= 0 ? t.block_start : -1, t.strstart - t.block_start, e), t.block_start = t.strstart, tt(t.strm);
+      }
+
+      function rt(t, e) {
+        t.pending_buf[t.pending++] = e;
+      }
+
+      function nt(t, e) {
+        t.pending_buf[t.pending++] = e >>> 8 & 255, t.pending_buf[t.pending++] = 255 & e;
+      }
+
+      function it(t, e) {
+        var r,
+            n,
+            i = t.max_chain_length,
+            o = t.strstart,
+            a = t.prev_length,
+            s = t.nice_match,
+            u = t.strstart > t.w_size - M ? t.strstart - (t.w_size - M) : 0,
+            f = t.window,
+            c = t.w_mask,
+            l = t.prev,
+            h = t.strstart + N,
+            d = f[o + a - 1],
+            p = f[o + a];
+        t.prev_length >= t.good_match && (i >>= 2), s > t.lookahead && (s = t.lookahead);
+
+        do {
+          if (f[(r = e) + a] === p && f[r + a - 1] === d && f[r] === f[o] && f[++r] === f[o + 1]) {
+            o += 2, r++;
+
+            do {} while (f[++o] === f[++r] && f[++o] === f[++r] && f[++o] === f[++r] && f[++o] === f[++r] && f[++o] === f[++r] && f[++o] === f[++r] && f[++o] === f[++r] && f[++o] === f[++r] && o < h);
+
+            if (n = N - (h - o), o = h - N, n > a) {
+              if (t.match_start = e, a = n, n >= s) break;
+              d = f[o + a - 1], p = f[o + a];
+            }
+          }
+        } while ((e = l[e & c]) > u && 0 != --i);
+
+        return a <= t.lookahead ? a : t.lookahead;
+      }
+
+      function ot(t) {
+        var e,
+            r,
+            n,
+            o,
+            u,
+            f,
+            c,
+            l,
+            h,
+            d,
+            p = t.w_size;
+
+        do {
+          if (o = t.window_size - t.lookahead - t.strstart, t.strstart >= p + (p - M)) {
+            i.arraySet(t.window, t.window, p, p, 0), t.match_start -= p, t.strstart -= p, t.block_start -= p, e = r = t.hash_size;
+
+            do {
+              n = t.head[--e], t.head[e] = n >= p ? n - p : 0;
+            } while (--r);
+
+            e = r = p;
+
+            do {
+              n = t.prev[--e], t.prev[e] = n >= p ? n - p : 0;
+            } while (--r);
+
+            o += p;
+          }
+
+          if (0 === t.strm.avail_in) break;
+          if (f = t.strm, c = t.window, l = t.strstart + t.lookahead, h = o, d = void 0, (d = f.avail_in) > h && (d = h), r = 0 === d ? 0 : (f.avail_in -= d, i.arraySet(c, f.input, f.next_in, d, l), 1 === f.state.wrap ? f.adler = a(f.adler, c, d, l) : 2 === f.state.wrap && (f.adler = s(f.adler, c, d, l)), f.next_in += d, f.total_in += d, d), t.lookahead += r, t.lookahead + t.insert >= F) for (u = t.strstart - t.insert, t.ins_h = t.window[u], t.ins_h = (t.ins_h << t.hash_shift ^ t.window[u + 1]) & t.hash_mask; t.insert && (t.ins_h = (t.ins_h << t.hash_shift ^ t.window[u + F - 1]) & t.hash_mask, t.prev[u & t.w_mask] = t.head[t.ins_h], t.head[t.ins_h] = u, u++, t.insert--, !(t.lookahead + t.insert < F)););
+        } while (t.lookahead < M && 0 !== t.strm.avail_in);
+      }
+
+      function at(t, e) {
+        for (var r, n;;) {
+          if (t.lookahead < M) {
+            if (ot(t), t.lookahead < M && e === f) return G;
+            if (0 === t.lookahead) break;
+          }
+
+          if (r = 0, t.lookahead >= F && (t.ins_h = (t.ins_h << t.hash_shift ^ t.window[t.strstart + F - 1]) & t.hash_mask, r = t.prev[t.strstart & t.w_mask] = t.head[t.ins_h], t.head[t.ins_h] = t.strstart), 0 !== r && t.strstart - r <= t.w_size - M && (t.match_length = it(t, r)), t.match_length >= F) {
+            if (n = o._tr_tally(t, t.strstart - t.match_start, t.match_length - F), t.lookahead -= t.match_length, t.match_length <= t.max_lazy_match && t.lookahead >= F) {
+              t.match_length--;
+
+              do {
+                t.strstart++, t.ins_h = (t.ins_h << t.hash_shift ^ t.window[t.strstart + F - 1]) & t.hash_mask, r = t.prev[t.strstart & t.w_mask] = t.head[t.ins_h], t.head[t.ins_h] = t.strstart;
+              } while (0 != --t.match_length);
+
+              t.strstart++;
+            } else t.strstart += t.match_length, t.match_length = 0, t.ins_h = t.window[t.strstart], t.ins_h = (t.ins_h << t.hash_shift ^ t.window[t.strstart + 1]) & t.hash_mask;
+          } else n = o._tr_tally(t, 0, t.window[t.strstart]), t.lookahead--, t.strstart++;
+          if (n && (et(t, !1), 0 === t.strm.avail_out)) return G;
+        }
+
+        return t.insert = t.strstart < F - 1 ? t.strstart : F - 1, e === h ? (et(t, !0), 0 === t.strm.avail_out ? W : K) : t.last_lit && (et(t, !1), 0 === t.strm.avail_out) ? G : Y;
+      }
+
+      function st(t, e) {
+        for (var r, n, i;;) {
+          if (t.lookahead < M) {
+            if (ot(t), t.lookahead < M && e === f) return G;
+            if (0 === t.lookahead) break;
+          }
+
+          if (r = 0, t.lookahead >= F && (t.ins_h = (t.ins_h << t.hash_shift ^ t.window[t.strstart + F - 1]) & t.hash_mask, r = t.prev[t.strstart & t.w_mask] = t.head[t.ins_h], t.head[t.ins_h] = t.strstart), t.prev_length = t.match_length, t.prev_match = t.match_start, t.match_length = F - 1, 0 !== r && t.prev_length < t.max_lazy_match && t.strstart - r <= t.w_size - M && (t.match_length = it(t, r), t.match_length <= 5 && (t.strategy === _ || t.match_length === F && t.strstart - t.match_start > 4096) && (t.match_length = F - 1)), t.prev_length >= F && t.match_length <= t.prev_length) {
+            i = t.strstart + t.lookahead - F, n = o._tr_tally(t, t.strstart - 1 - t.prev_match, t.prev_length - F), t.lookahead -= t.prev_length - 1, t.prev_length -= 2;
+
+            do {
+              ++t.strstart <= i && (t.ins_h = (t.ins_h << t.hash_shift ^ t.window[t.strstart + F - 1]) & t.hash_mask, r = t.prev[t.strstart & t.w_mask] = t.head[t.ins_h], t.head[t.ins_h] = t.strstart);
+            } while (0 != --t.prev_length);
+
+            if (t.match_available = 0, t.match_length = F - 1, t.strstart++, n && (et(t, !1), 0 === t.strm.avail_out)) return G;
+          } else if (t.match_available) {
+            if ((n = o._tr_tally(t, 0, t.window[t.strstart - 1])) && et(t, !1), t.strstart++, t.lookahead--, 0 === t.strm.avail_out) return G;
+          } else t.match_available = 1, t.strstart++, t.lookahead--;
+        }
+
+        return t.match_available && (n = o._tr_tally(t, 0, t.window[t.strstart - 1]), t.match_available = 0), t.insert = t.strstart < F - 1 ? t.strstart : F - 1, e === h ? (et(t, !0), 0 === t.strm.avail_out ? W : K) : t.last_lit && (et(t, !1), 0 === t.strm.avail_out) ? G : Y;
+      }
+
+      function ut(t, e, r, n, i) {
+        this.good_length = t, this.max_lazy = e, this.nice_length = r, this.max_chain = n, this.func = i;
+      }
+
+      function ft() {
+        this.strm = null, this.status = 0, this.pending_buf = null, this.pending_buf_size = 0, this.pending_out = 0, this.pending = 0, this.wrap = 0, this.gzhead = null, this.gzindex = 0, this.method = A, this.last_flush = -1, this.w_size = 0, this.w_bits = 0, this.w_mask = 0, this.window = null, this.window_size = 0, this.prev = null, this.head = null, this.ins_h = 0, this.hash_size = 0, this.hash_bits = 0, this.hash_mask = 0, this.hash_shift = 0, this.block_start = 0, this.match_length = 0, this.prev_match = 0, this.match_available = 0, this.strstart = 0, this.match_start = 0, this.lookahead = 0, this.prev_length = 0, this.max_chain_length = 0, this.max_lazy_match = 0, this.level = 0, this.strategy = 0, this.good_match = 0, this.nice_match = 0, this.dyn_ltree = new i.Buf16(2 * B), this.dyn_dtree = new i.Buf16(2 * (2 * I + 1)), this.bl_tree = new i.Buf16(2 * (2 * L + 1)), J(this.dyn_ltree), J(this.dyn_dtree), J(this.bl_tree), this.l_desc = null, this.d_desc = null, this.bl_desc = null, this.bl_count = new i.Buf16(P + 1), this.heap = new i.Buf16(2 * O + 1), J(this.heap), this.heap_len = 0, this.heap_max = 0, this.depth = new i.Buf16(2 * O + 1), J(this.depth), this.l_buf = 0, this.lit_bufsize = 0, this.last_lit = 0, this.d_buf = 0, this.opt_len = 0, this.static_len = 0, this.matches = 0, this.insert = 0, this.bi_buf = 0, this.bi_valid = 0;
+      }
+
+      function ct(t) {
+        var e;
+        return t && t.state ? (t.total_in = t.total_out = 0, t.data_type = k, (e = t.state).pending = 0, e.pending_out = 0, e.wrap < 0 && (e.wrap = -e.wrap), e.status = e.wrap ? z : H, t.adler = 2 === e.wrap ? 0 : 1, e.last_flush = f, o._tr_init(e), p) : X(t, v);
+      }
+
+      function lt(t) {
+        var e,
+            r = ct(t);
+        return r === p && ((e = t.state).window_size = 2 * e.w_size, J(e.head), e.max_lazy_match = n[e.level].max_lazy, e.good_match = n[e.level].good_length, e.nice_match = n[e.level].nice_length, e.max_chain_length = n[e.level].max_chain, e.strstart = 0, e.block_start = 0, e.lookahead = 0, e.insert = 0, e.match_length = e.prev_length = F - 1, e.match_available = 0, e.ins_h = 0), r;
+      }
+
+      function ht(t, e, r, n, o, a) {
+        if (!t) return v;
+        var s = 1;
+        if (e === b && (e = 6), n < 0 ? (s = 0, n = -n) : n > 15 && (s = 2, n -= 16), o < 1 || o > C || r !== A || n < 8 || n > 15 || e < 0 || e > 9 || a < 0 || a > E) return X(t, v);
+        8 === n && (n = 9);
+        var u = new ft();
+        return t.state = u, u.strm = t, u.wrap = s, u.gzhead = null, u.w_bits = n, u.w_size = 1 << u.w_bits, u.w_mask = u.w_size - 1, u.hash_bits = o + 7, u.hash_size = 1 << u.hash_bits, u.hash_mask = u.hash_size - 1, u.hash_shift = ~~((u.hash_bits + F - 1) / F), u.window = new i.Buf8(2 * u.w_size), u.head = new i.Buf16(u.hash_size), u.prev = new i.Buf16(u.w_size), u.lit_bufsize = 1 << o + 6, u.pending_buf_size = 4 * u.lit_bufsize, u.pending_buf = new i.Buf8(u.pending_buf_size), u.d_buf = 1 * u.lit_bufsize, u.l_buf = 3 * u.lit_bufsize, u.level = e, u.strategy = a, u.method = r, lt(t);
+      }
+
+      n = [new ut(0, 0, 0, 0, function (t, e) {
+        var r = 65535;
+
+        for (r > t.pending_buf_size - 5 && (r = t.pending_buf_size - 5);;) {
+          if (t.lookahead <= 1) {
+            if (ot(t), 0 === t.lookahead && e === f) return G;
+            if (0 === t.lookahead) break;
+          }
+
+          t.strstart += t.lookahead, t.lookahead = 0;
+          var n = t.block_start + r;
+          if ((0 === t.strstart || t.strstart >= n) && (t.lookahead = t.strstart - n, t.strstart = n, et(t, !1), 0 === t.strm.avail_out)) return G;
+          if (t.strstart - t.block_start >= t.w_size - M && (et(t, !1), 0 === t.strm.avail_out)) return G;
+        }
+
+        return t.insert = 0, e === h ? (et(t, !0), 0 === t.strm.avail_out ? W : K) : (t.strstart > t.block_start && (et(t, !1), t.strm.avail_out), G);
+      }), new ut(4, 4, 8, 4, at), new ut(4, 5, 16, 8, at), new ut(4, 6, 32, 32, at), new ut(4, 4, 16, 16, st), new ut(8, 16, 32, 32, st), new ut(8, 16, 128, 128, st), new ut(8, 32, 128, 256, st), new ut(32, 128, 258, 1024, st), new ut(32, 258, 258, 4096, st)], e.deflateInit = function (t, e) {
+        return ht(t, e, A, T, R, S);
+      }, e.deflateInit2 = ht, e.deflateReset = lt, e.deflateResetKeep = ct, e.deflateSetHeader = function (t, e) {
+        return t && t.state ? 2 !== t.state.wrap ? v : (t.state.gzhead = e, p) : v;
+      }, e.deflate = function (t, e) {
+        var r, i, a, u;
+        if (!t || !t.state || e > d || e < 0) return t ? X(t, v) : v;
+        if (i = t.state, !t.output || !t.input && 0 !== t.avail_in || i.status === V && e !== h) return X(t, 0 === t.avail_out ? m : v);
+        if (i.strm = t, r = i.last_flush, i.last_flush = e, i.status === z) if (2 === i.wrap) t.adler = 0, rt(i, 31), rt(i, 139), rt(i, 8), i.gzhead ? (rt(i, (i.gzhead.text ? 1 : 0) + (i.gzhead.hcrc ? 2 : 0) + (i.gzhead.extra ? 4 : 0) + (i.gzhead.name ? 8 : 0) + (i.gzhead.comment ? 16 : 0)), rt(i, 255 & i.gzhead.time), rt(i, i.gzhead.time >> 8 & 255), rt(i, i.gzhead.time >> 16 & 255), rt(i, i.gzhead.time >> 24 & 255), rt(i, 9 === i.level ? 2 : i.strategy >= w || i.level < 2 ? 4 : 0), rt(i, 255 & i.gzhead.os), i.gzhead.extra && i.gzhead.extra.length && (rt(i, 255 & i.gzhead.extra.length), rt(i, i.gzhead.extra.length >> 8 & 255)), i.gzhead.hcrc && (t.adler = s(t.adler, i.pending_buf, i.pending, 0)), i.gzindex = 0, i.status = U) : (rt(i, 0), rt(i, 0), rt(i, 0), rt(i, 0), rt(i, 0), rt(i, 9 === i.level ? 2 : i.strategy >= w || i.level < 2 ? 4 : 0), rt(i, Q), i.status = H);else {
+          var y = A + (i.w_bits - 8 << 4) << 8;
+          y |= (i.strategy >= w || i.level < 2 ? 0 : i.level < 6 ? 1 : 6 === i.level ? 2 : 3) << 6, 0 !== i.strstart && (y |= j), y += 31 - y % 31, i.status = H, nt(i, y), 0 !== i.strstart && (nt(i, t.adler >>> 16), nt(i, 65535 & t.adler)), t.adler = 1;
+        }
+        if (i.status === U) if (i.gzhead.extra) {
+          for (a = i.pending; i.gzindex < (65535 & i.gzhead.extra.length) && (i.pending !== i.pending_buf_size || (i.gzhead.hcrc && i.pending > a && (t.adler = s(t.adler, i.pending_buf, i.pending - a, a)), tt(t), a = i.pending, i.pending !== i.pending_buf_size));) rt(i, 255 & i.gzhead.extra[i.gzindex]), i.gzindex++;
+
+          i.gzhead.hcrc && i.pending > a && (t.adler = s(t.adler, i.pending_buf, i.pending - a, a)), i.gzindex === i.gzhead.extra.length && (i.gzindex = 0, i.status = D);
+        } else i.status = D;
+        if (i.status === D) if (i.gzhead.name) {
+          a = i.pending;
+
+          do {
+            if (i.pending === i.pending_buf_size && (i.gzhead.hcrc && i.pending > a && (t.adler = s(t.adler, i.pending_buf, i.pending - a, a)), tt(t), a = i.pending, i.pending === i.pending_buf_size)) {
+              u = 1;
+              break;
+            }
+
+            u = i.gzindex < i.gzhead.name.length ? 255 & i.gzhead.name.charCodeAt(i.gzindex++) : 0, rt(i, u);
+          } while (0 !== u);
+
+          i.gzhead.hcrc && i.pending > a && (t.adler = s(t.adler, i.pending_buf, i.pending - a, a)), 0 === u && (i.gzindex = 0, i.status = q);
+        } else i.status = q;
+        if (i.status === q) if (i.gzhead.comment) {
+          a = i.pending;
+
+          do {
+            if (i.pending === i.pending_buf_size && (i.gzhead.hcrc && i.pending > a && (t.adler = s(t.adler, i.pending_buf, i.pending - a, a)), tt(t), a = i.pending, i.pending === i.pending_buf_size)) {
+              u = 1;
+              break;
+            }
+
+            u = i.gzindex < i.gzhead.comment.length ? 255 & i.gzhead.comment.charCodeAt(i.gzindex++) : 0, rt(i, u);
+          } while (0 !== u);
+
+          i.gzhead.hcrc && i.pending > a && (t.adler = s(t.adler, i.pending_buf, i.pending - a, a)), 0 === u && (i.status = Z);
+        } else i.status = Z;
+
+        if (i.status === Z && (i.gzhead.hcrc ? (i.pending + 2 > i.pending_buf_size && tt(t), i.pending + 2 <= i.pending_buf_size && (rt(i, 255 & t.adler), rt(i, t.adler >> 8 & 255), t.adler = 0, i.status = H)) : i.status = H), 0 !== i.pending) {
+          if (tt(t), 0 === t.avail_out) return i.last_flush = -1, p;
+        } else if (0 === t.avail_in && $(e) <= $(r) && e !== h) return X(t, m);
+
+        if (i.status === V && 0 !== t.avail_in) return X(t, m);
+
+        if (0 !== t.avail_in || 0 !== i.lookahead || e !== f && i.status !== V) {
+          var b = i.strategy === w ? function (t, e) {
+            for (var r;;) {
+              if (0 === t.lookahead && (ot(t), 0 === t.lookahead)) {
+                if (e === f) return G;
+                break;
+              }
+
+              if (t.match_length = 0, r = o._tr_tally(t, 0, t.window[t.strstart]), t.lookahead--, t.strstart++, r && (et(t, !1), 0 === t.strm.avail_out)) return G;
+            }
+
+            return t.insert = 0, e === h ? (et(t, !0), 0 === t.strm.avail_out ? W : K) : t.last_lit && (et(t, !1), 0 === t.strm.avail_out) ? G : Y;
+          }(i, e) : i.strategy === x ? function (t, e) {
+            for (var r, n, i, a, s = t.window;;) {
+              if (t.lookahead <= N) {
+                if (ot(t), t.lookahead <= N && e === f) return G;
+                if (0 === t.lookahead) break;
+              }
+
+              if (t.match_length = 0, t.lookahead >= F && t.strstart > 0 && (n = s[i = t.strstart - 1]) === s[++i] && n === s[++i] && n === s[++i]) {
+                a = t.strstart + N;
+
+                do {} while (n === s[++i] && n === s[++i] && n === s[++i] && n === s[++i] && n === s[++i] && n === s[++i] && n === s[++i] && n === s[++i] && i < a);
+
+                t.match_length = N - (a - i), t.match_length > t.lookahead && (t.match_length = t.lookahead);
+              }
+
+              if (t.match_length >= F ? (r = o._tr_tally(t, 1, t.match_length - F), t.lookahead -= t.match_length, t.strstart += t.match_length, t.match_length = 0) : (r = o._tr_tally(t, 0, t.window[t.strstart]), t.lookahead--, t.strstart++), r && (et(t, !1), 0 === t.strm.avail_out)) return G;
+            }
+
+            return t.insert = 0, e === h ? (et(t, !0), 0 === t.strm.avail_out ? W : K) : t.last_lit && (et(t, !1), 0 === t.strm.avail_out) ? G : Y;
+          }(i, e) : n[i.level].func(i, e);
+          if (b !== W && b !== K || (i.status = V), b === G || b === W) return 0 === t.avail_out && (i.last_flush = -1), p;
+          if (b === Y && (e === c ? o._tr_align(i) : e !== d && (o._tr_stored_block(i, 0, 0, !1), e === l && (J(i.head), 0 === i.lookahead && (i.strstart = 0, i.block_start = 0, i.insert = 0))), tt(t), 0 === t.avail_out)) return i.last_flush = -1, p;
+        }
+
+        return e !== h ? p : i.wrap <= 0 ? g : (2 === i.wrap ? (rt(i, 255 & t.adler), rt(i, t.adler >> 8 & 255), rt(i, t.adler >> 16 & 255), rt(i, t.adler >> 24 & 255), rt(i, 255 & t.total_in), rt(i, t.total_in >> 8 & 255), rt(i, t.total_in >> 16 & 255), rt(i, t.total_in >> 24 & 255)) : (nt(i, t.adler >>> 16), nt(i, 65535 & t.adler)), tt(t), i.wrap > 0 && (i.wrap = -i.wrap), 0 !== i.pending ? p : g);
+      }, e.deflateEnd = function (t) {
+        var e;
+        return t && t.state ? (e = t.state.status) !== z && e !== U && e !== D && e !== q && e !== Z && e !== H && e !== V ? X(t, v) : (t.state = null, e === H ? X(t, y) : p) : v;
+      }, e.deflateSetDictionary = function (t, e) {
+        var r,
+            n,
+            o,
+            s,
+            u,
+            f,
+            c,
+            l,
+            h = e.length;
+        if (!t || !t.state) return v;
+        if (2 === (s = (r = t.state).wrap) || 1 === s && r.status !== z || r.lookahead) return v;
+
+        for (1 === s && (t.adler = a(t.adler, e, h, 0)), r.wrap = 0, h >= r.w_size && (0 === s && (J(r.head), r.strstart = 0, r.block_start = 0, r.insert = 0), l = new i.Buf8(r.w_size), i.arraySet(l, e, h - r.w_size, r.w_size, 0), e = l, h = r.w_size), u = t.avail_in, f = t.next_in, c = t.input, t.avail_in = h, t.next_in = 0, t.input = e, ot(r); r.lookahead >= F;) {
+          n = r.strstart, o = r.lookahead - (F - 1);
+
+          do {
+            r.ins_h = (r.ins_h << r.hash_shift ^ r.window[n + F - 1]) & r.hash_mask, r.prev[n & r.w_mask] = r.head[r.ins_h], r.head[r.ins_h] = n, n++;
+          } while (--o);
+
+          r.strstart = n, r.lookahead = F - 1, ot(r);
+        }
+
+        return r.strstart += r.lookahead, r.block_start = r.strstart, r.insert = r.lookahead, r.lookahead = 0, r.match_length = r.prev_length = F - 1, r.match_available = 0, t.next_in = f, t.input = c, t.avail_in = u, r.wrap = s, p;
+      }, e.deflateInfo = "pako deflate (from Nodeca project)";
+    }, function (t, e, r) {
+
+      var n = r(72),
+          i = 4,
+          o = 0,
+          a = 1,
+          s = 2;
+
+      function u(t) {
+        for (var e = t.length; --e >= 0;) t[e] = 0;
+      }
+
+      var f = 0,
+          c = 1,
+          l = 2,
+          h = 29,
+          d = 256,
+          p = d + 1 + h,
+          g = 30,
+          v = 19,
+          y = 2 * p + 1,
+          m = 15,
+          b = 16,
+          _ = 7,
+          w = 256,
+          x = 16,
+          E = 17,
+          S = 18,
+          k = [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0],
+          A = [0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13],
+          C = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 3, 7],
+          T = [16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15],
+          R = new Array(2 * (p + 2));
+      u(R);
+      var O = new Array(2 * g);
+      u(O);
+      var I = new Array(512);
+      u(I);
+      var L = new Array(256);
+      u(L);
+      var B = new Array(h);
+      u(B);
+      var P,
+          F,
+          N,
+          M = new Array(g);
+
+      function j(t, e, r, n, i) {
+        this.static_tree = t, this.extra_bits = e, this.extra_base = r, this.elems = n, this.max_length = i, this.has_stree = t && t.length;
+      }
+
+      function z(t, e) {
+        this.dyn_tree = t, this.max_code = 0, this.stat_desc = e;
+      }
+
+      function U(t) {
+        return t < 256 ? I[t] : I[256 + (t >>> 7)];
+      }
+
+      function D(t, e) {
+        t.pending_buf[t.pending++] = 255 & e, t.pending_buf[t.pending++] = e >>> 8 & 255;
+      }
+
+      function q(t, e, r) {
+        t.bi_valid > b - r ? (t.bi_buf |= e << t.bi_valid & 65535, D(t, t.bi_buf), t.bi_buf = e >> b - t.bi_valid, t.bi_valid += r - b) : (t.bi_buf |= e << t.bi_valid & 65535, t.bi_valid += r);
+      }
+
+      function Z(t, e, r) {
+        q(t, r[2 * e], r[2 * e + 1]);
+      }
+
+      function H(t, e) {
+        var r = 0;
+
+        do {
+          r |= 1 & t, t >>>= 1, r <<= 1;
+        } while (--e > 0);
+
+        return r >>> 1;
+      }
+
+      function V(t, e, r) {
+        var n,
+            i,
+            o = new Array(m + 1),
+            a = 0;
+
+        for (n = 1; n <= m; n++) o[n] = a = a + r[n - 1] << 1;
+
+        for (i = 0; i <= e; i++) {
+          var s = t[2 * i + 1];
+          0 !== s && (t[2 * i] = H(o[s]++, s));
+        }
+      }
+
+      function G(t) {
+        var e;
+
+        for (e = 0; e < p; e++) t.dyn_ltree[2 * e] = 0;
+
+        for (e = 0; e < g; e++) t.dyn_dtree[2 * e] = 0;
+
+        for (e = 0; e < v; e++) t.bl_tree[2 * e] = 0;
+
+        t.dyn_ltree[2 * w] = 1, t.opt_len = t.static_len = 0, t.last_lit = t.matches = 0;
+      }
+
+      function Y(t) {
+        t.bi_valid > 8 ? D(t, t.bi_buf) : t.bi_valid > 0 && (t.pending_buf[t.pending++] = t.bi_buf), t.bi_buf = 0, t.bi_valid = 0;
+      }
+
+      function W(t, e, r, n) {
+        var i = 2 * e,
+            o = 2 * r;
+        return t[i] < t[o] || t[i] === t[o] && n[e] <= n[r];
+      }
+
+      function K(t, e, r) {
+        for (var n = t.heap[r], i = r << 1; i <= t.heap_len && (i < t.heap_len && W(e, t.heap[i + 1], t.heap[i], t.depth) && i++, !W(e, n, t.heap[i], t.depth));) t.heap[r] = t.heap[i], r = i, i <<= 1;
+
+        t.heap[r] = n;
+      }
+
+      function Q(t, e, r) {
+        var n,
+            i,
+            o,
+            a,
+            s = 0;
+        if (0 !== t.last_lit) do {
+          n = t.pending_buf[t.d_buf + 2 * s] << 8 | t.pending_buf[t.d_buf + 2 * s + 1], i = t.pending_buf[t.l_buf + s], s++, 0 === n ? Z(t, i, e) : (Z(t, (o = L[i]) + d + 1, e), 0 !== (a = k[o]) && q(t, i -= B[o], a), Z(t, o = U(--n), r), 0 !== (a = A[o]) && q(t, n -= M[o], a));
+        } while (s < t.last_lit);
+        Z(t, w, e);
+      }
+
+      function X(t, e) {
+        var r,
+            n,
+            i,
+            o = e.dyn_tree,
+            a = e.stat_desc.static_tree,
+            s = e.stat_desc.has_stree,
+            u = e.stat_desc.elems,
+            f = -1;
+
+        for (t.heap_len = 0, t.heap_max = y, r = 0; r < u; r++) 0 !== o[2 * r] ? (t.heap[++t.heap_len] = f = r, t.depth[r] = 0) : o[2 * r + 1] = 0;
+
+        for (; t.heap_len < 2;) o[2 * (i = t.heap[++t.heap_len] = f < 2 ? ++f : 0)] = 1, t.depth[i] = 0, t.opt_len--, s && (t.static_len -= a[2 * i + 1]);
+
+        for (e.max_code = f, r = t.heap_len >> 1; r >= 1; r--) K(t, o, r);
+
+        i = u;
+
+        do {
+          r = t.heap[1], t.heap[1] = t.heap[t.heap_len--], K(t, o, 1), n = t.heap[1], t.heap[--t.heap_max] = r, t.heap[--t.heap_max] = n, o[2 * i] = o[2 * r] + o[2 * n], t.depth[i] = (t.depth[r] >= t.depth[n] ? t.depth[r] : t.depth[n]) + 1, o[2 * r + 1] = o[2 * n + 1] = i, t.heap[1] = i++, K(t, o, 1);
+        } while (t.heap_len >= 2);
+
+        t.heap[--t.heap_max] = t.heap[1], function (t, e) {
+          var r,
+              n,
+              i,
+              o,
+              a,
+              s,
+              u = e.dyn_tree,
+              f = e.max_code,
+              c = e.stat_desc.static_tree,
+              l = e.stat_desc.has_stree,
+              h = e.stat_desc.extra_bits,
+              d = e.stat_desc.extra_base,
+              p = e.stat_desc.max_length,
+              g = 0;
+
+          for (o = 0; o <= m; o++) t.bl_count[o] = 0;
+
+          for (u[2 * t.heap[t.heap_max] + 1] = 0, r = t.heap_max + 1; r < y; r++) (o = u[2 * u[2 * (n = t.heap[r]) + 1] + 1] + 1) > p && (o = p, g++), u[2 * n + 1] = o, n > f || (t.bl_count[o]++, a = 0, n >= d && (a = h[n - d]), s = u[2 * n], t.opt_len += s * (o + a), l && (t.static_len += s * (c[2 * n + 1] + a)));
+
+          if (0 !== g) {
+            do {
+              for (o = p - 1; 0 === t.bl_count[o];) o--;
+
+              t.bl_count[o]--, t.bl_count[o + 1] += 2, t.bl_count[p]--, g -= 2;
+            } while (g > 0);
+
+            for (o = p; 0 !== o; o--) for (n = t.bl_count[o]; 0 !== n;) (i = t.heap[--r]) > f || (u[2 * i + 1] !== o && (t.opt_len += (o - u[2 * i + 1]) * u[2 * i], u[2 * i + 1] = o), n--);
+          }
+        }(t, e), V(o, f, t.bl_count);
+      }
+
+      function $(t, e, r) {
+        var n,
+            i,
+            o = -1,
+            a = e[1],
+            s = 0,
+            u = 7,
+            f = 4;
+
+        for (0 === a && (u = 138, f = 3), e[2 * (r + 1) + 1] = 65535, n = 0; n <= r; n++) i = a, a = e[2 * (n + 1) + 1], ++s < u && i === a || (s < f ? t.bl_tree[2 * i] += s : 0 !== i ? (i !== o && t.bl_tree[2 * i]++, t.bl_tree[2 * x]++) : s <= 10 ? t.bl_tree[2 * E]++ : t.bl_tree[2 * S]++, s = 0, o = i, 0 === a ? (u = 138, f = 3) : i === a ? (u = 6, f = 3) : (u = 7, f = 4));
+      }
+
+      function J(t, e, r) {
+        var n,
+            i,
+            o = -1,
+            a = e[1],
+            s = 0,
+            u = 7,
+            f = 4;
+
+        for (0 === a && (u = 138, f = 3), n = 0; n <= r; n++) if (i = a, a = e[2 * (n + 1) + 1], !(++s < u && i === a)) {
+          if (s < f) do {
+            Z(t, i, t.bl_tree);
+          } while (0 != --s);else 0 !== i ? (i !== o && (Z(t, i, t.bl_tree), s--), Z(t, x, t.bl_tree), q(t, s - 3, 2)) : s <= 10 ? (Z(t, E, t.bl_tree), q(t, s - 3, 3)) : (Z(t, S, t.bl_tree), q(t, s - 11, 7));
+          s = 0, o = i, 0 === a ? (u = 138, f = 3) : i === a ? (u = 6, f = 3) : (u = 7, f = 4);
+        }
+      }
+
+      u(M);
+      var tt = !1;
+
+      function et(t, e, r, i) {
+        q(t, (f << 1) + (i ? 1 : 0), 3), function (t, e, r, i) {
+          Y(t), i && (D(t, r), D(t, ~r)), n.arraySet(t.pending_buf, t.window, e, r, t.pending), t.pending += r;
+        }(t, e, r, !0);
+      }
+
+      e._tr_init = function (t) {
+        tt || (!function () {
+          var t,
+              e,
+              r,
+              n,
+              i,
+              o = new Array(m + 1);
+
+          for (r = 0, n = 0; n < h - 1; n++) for (B[n] = r, t = 0; t < 1 << k[n]; t++) L[r++] = n;
+
+          for (L[r - 1] = n, i = 0, n = 0; n < 16; n++) for (M[n] = i, t = 0; t < 1 << A[n]; t++) I[i++] = n;
+
+          for (i >>= 7; n < g; n++) for (M[n] = i << 7, t = 0; t < 1 << A[n] - 7; t++) I[256 + i++] = n;
+
+          for (e = 0; e <= m; e++) o[e] = 0;
+
+          for (t = 0; t <= 143;) R[2 * t + 1] = 8, t++, o[8]++;
+
+          for (; t <= 255;) R[2 * t + 1] = 9, t++, o[9]++;
+
+          for (; t <= 279;) R[2 * t + 1] = 7, t++, o[7]++;
+
+          for (; t <= 287;) R[2 * t + 1] = 8, t++, o[8]++;
+
+          for (V(R, p + 1, o), t = 0; t < g; t++) O[2 * t + 1] = 5, O[2 * t] = H(t, 5);
+
+          P = new j(R, k, d + 1, p, m), F = new j(O, A, 0, g, m), N = new j(new Array(0), C, 0, v, _);
+        }(), tt = !0), t.l_desc = new z(t.dyn_ltree, P), t.d_desc = new z(t.dyn_dtree, F), t.bl_desc = new z(t.bl_tree, N), t.bi_buf = 0, t.bi_valid = 0, G(t);
+      }, e._tr_stored_block = et, e._tr_flush_block = function (t, e, r, n) {
+        var u,
+            f,
+            h = 0;
+        t.level > 0 ? (t.strm.data_type === s && (t.strm.data_type = function (t) {
+          var e,
+              r = 4093624447;
+
+          for (e = 0; e <= 31; e++, r >>>= 1) if (1 & r && 0 !== t.dyn_ltree[2 * e]) return o;
+
+          if (0 !== t.dyn_ltree[18] || 0 !== t.dyn_ltree[20] || 0 !== t.dyn_ltree[26]) return a;
+
+          for (e = 32; e < d; e++) if (0 !== t.dyn_ltree[2 * e]) return a;
+
+          return o;
+        }(t)), X(t, t.l_desc), X(t, t.d_desc), h = function (t) {
+          var e;
+
+          for ($(t, t.dyn_ltree, t.l_desc.max_code), $(t, t.dyn_dtree, t.d_desc.max_code), X(t, t.bl_desc), e = v - 1; e >= 3 && 0 === t.bl_tree[2 * T[e] + 1]; e--);
+
+          return t.opt_len += 3 * (e + 1) + 5 + 5 + 4, e;
+        }(t), u = t.opt_len + 3 + 7 >>> 3, (f = t.static_len + 3 + 7 >>> 3) <= u && (u = f)) : u = f = r + 5, r + 4 <= u && -1 !== e ? et(t, e, r, n) : t.strategy === i || f === u ? (q(t, (c << 1) + (n ? 1 : 0), 3), Q(t, R, O)) : (q(t, (l << 1) + (n ? 1 : 0), 3), function (t, e, r, n) {
+          var i;
+
+          for (q(t, e - 257, 5), q(t, r - 1, 5), q(t, n - 4, 4), i = 0; i < n; i++) q(t, t.bl_tree[2 * T[i] + 1], 3);
+
+          J(t, t.dyn_ltree, e - 1), J(t, t.dyn_dtree, r - 1);
+        }(t, t.l_desc.max_code + 1, t.d_desc.max_code + 1, h + 1), Q(t, t.dyn_ltree, t.dyn_dtree)), G(t), n && Y(t);
+      }, e._tr_tally = function (t, e, r) {
+        return t.pending_buf[t.d_buf + 2 * t.last_lit] = e >>> 8 & 255, t.pending_buf[t.d_buf + 2 * t.last_lit + 1] = 255 & e, t.pending_buf[t.l_buf + t.last_lit] = 255 & r, t.last_lit++, 0 === e ? t.dyn_ltree[2 * r]++ : (t.matches++, e--, t.dyn_ltree[2 * (L[r] + d + 1)]++, t.dyn_dtree[2 * U(e)]++), t.last_lit === t.lit_bufsize - 1;
+      }, e._tr_align = function (t) {
+        q(t, c << 1, 3), Z(t, w, R), function (t) {
+          16 === t.bi_valid ? (D(t, t.bi_buf), t.bi_buf = 0, t.bi_valid = 0) : t.bi_valid >= 8 && (t.pending_buf[t.pending++] = 255 & t.bi_buf, t.bi_buf >>= 8, t.bi_valid -= 8);
+        }(t);
+      };
+    }, function (t, e, r) {
+
+      t.exports = {
+        2: "need dictionary",
+        1: "stream end",
+        0: "",
+        "-1": "file error",
+        "-2": "stream error",
+        "-3": "data error",
+        "-4": "insufficient memory",
+        "-5": "buffer error",
+        "-6": "incompatible version"
+      };
+    }, function (t, e, r) {
+
+      var n = r(72),
+          i = r(134),
+          o = r(135),
+          a = r(221),
+          s = r(222),
+          u = 0,
+          f = 1,
+          c = 2,
+          l = 4,
+          h = 5,
+          d = 6,
+          p = 0,
+          g = 1,
+          v = 2,
+          y = -2,
+          m = -3,
+          b = -4,
+          _ = -5,
+          w = 8,
+          x = 1,
+          E = 2,
+          S = 3,
+          k = 4,
+          A = 5,
+          C = 6,
+          T = 7,
+          R = 8,
+          O = 9,
+          I = 10,
+          L = 11,
+          B = 12,
+          P = 13,
+          F = 14,
+          N = 15,
+          M = 16,
+          j = 17,
+          z = 18,
+          U = 19,
+          D = 20,
+          q = 21,
+          Z = 22,
+          H = 23,
+          V = 24,
+          G = 25,
+          Y = 26,
+          W = 27,
+          K = 28,
+          Q = 29,
+          X = 30,
+          $ = 31,
+          J = 32,
+          tt = 852,
+          et = 592,
+          rt = 15;
+
+      function nt(t) {
+        return (t >>> 24 & 255) + (t >>> 8 & 65280) + ((65280 & t) << 8) + ((255 & t) << 24);
+      }
+
+      function it() {
+        this.mode = 0, this.last = !1, this.wrap = 0, this.havedict = !1, this.flags = 0, this.dmax = 0, this.check = 0, this.total = 0, this.head = null, this.wbits = 0, this.wsize = 0, this.whave = 0, this.wnext = 0, this.window = null, this.hold = 0, this.bits = 0, this.length = 0, this.offset = 0, this.extra = 0, this.lencode = null, this.distcode = null, this.lenbits = 0, this.distbits = 0, this.ncode = 0, this.nlen = 0, this.ndist = 0, this.have = 0, this.next = null, this.lens = new n.Buf16(320), this.work = new n.Buf16(288), this.lendyn = null, this.distdyn = null, this.sane = 0, this.back = 0, this.was = 0;
+      }
+
+      function ot(t) {
+        var e;
+        return t && t.state ? (e = t.state, t.total_in = t.total_out = e.total = 0, t.msg = "", e.wrap && (t.adler = 1 & e.wrap), e.mode = x, e.last = 0, e.havedict = 0, e.dmax = 32768, e.head = null, e.hold = 0, e.bits = 0, e.lencode = e.lendyn = new n.Buf32(tt), e.distcode = e.distdyn = new n.Buf32(et), e.sane = 1, e.back = -1, p) : y;
+      }
+
+      function at(t) {
+        var e;
+        return t && t.state ? ((e = t.state).wsize = 0, e.whave = 0, e.wnext = 0, ot(t)) : y;
+      }
+
+      function st(t, e) {
+        var r, n;
+        return t && t.state ? (n = t.state, e < 0 ? (r = 0, e = -e) : (r = 1 + (e >> 4), e < 48 && (e &= 15)), e && (e < 8 || e > 15) ? y : (null !== n.window && n.wbits !== e && (n.window = null), n.wrap = r, n.wbits = e, at(t))) : y;
+      }
+
+      function ut(t, e) {
+        var r, n;
+        return t ? (n = new it(), t.state = n, n.window = null, (r = st(t, e)) !== p && (t.state = null), r) : y;
+      }
+
+      var ft,
+          ct,
+          lt = !0;
+
+      function ht(t) {
+        if (lt) {
+          var e;
+
+          for (ft = new n.Buf32(512), ct = new n.Buf32(32), e = 0; e < 144;) t.lens[e++] = 8;
+
+          for (; e < 256;) t.lens[e++] = 9;
+
+          for (; e < 280;) t.lens[e++] = 7;
+
+          for (; e < 288;) t.lens[e++] = 8;
+
+          for (s(f, t.lens, 0, 288, ft, 0, t.work, {
+            bits: 9
+          }), e = 0; e < 32;) t.lens[e++] = 5;
+
+          s(c, t.lens, 0, 32, ct, 0, t.work, {
+            bits: 5
+          }), lt = !1;
+        }
+
+        t.lencode = ft, t.lenbits = 9, t.distcode = ct, t.distbits = 5;
+      }
+
+      function dt(t, e, r, i) {
+        var o,
+            a = t.state;
+        return null === a.window && (a.wsize = 1 << a.wbits, a.wnext = 0, a.whave = 0, a.window = new n.Buf8(a.wsize)), i >= a.wsize ? (n.arraySet(a.window, e, r - a.wsize, a.wsize, 0), a.wnext = 0, a.whave = a.wsize) : ((o = a.wsize - a.wnext) > i && (o = i), n.arraySet(a.window, e, r - i, o, a.wnext), (i -= o) ? (n.arraySet(a.window, e, r - i, i, 0), a.wnext = i, a.whave = a.wsize) : (a.wnext += o, a.wnext === a.wsize && (a.wnext = 0), a.whave < a.wsize && (a.whave += o))), 0;
+      }
+
+      e.inflateReset = at, e.inflateReset2 = st, e.inflateResetKeep = ot, e.inflateInit = function (t) {
+        return ut(t, rt);
+      }, e.inflateInit2 = ut, e.inflate = function (t, e) {
+        var r,
+            tt,
+            et,
+            rt,
+            it,
+            ot,
+            at,
+            st,
+            ut,
+            ft,
+            ct,
+            lt,
+            pt,
+            gt,
+            vt,
+            yt,
+            mt,
+            bt,
+            _t,
+            wt,
+            xt,
+            Et,
+            St,
+            kt,
+            At = 0,
+            Ct = new n.Buf8(4),
+            Tt = [16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15];
+
+        if (!t || !t.state || !t.output || !t.input && 0 !== t.avail_in) return y;
+        (r = t.state).mode === B && (r.mode = P), it = t.next_out, et = t.output, at = t.avail_out, rt = t.next_in, tt = t.input, ot = t.avail_in, st = r.hold, ut = r.bits, ft = ot, ct = at, Et = p;
+
+        t: for (;;) switch (r.mode) {
+          case x:
+            if (0 === r.wrap) {
+              r.mode = P;
+              break;
+            }
+
+            for (; ut < 16;) {
+              if (0 === ot) break t;
+              ot--, st += tt[rt++] << ut, ut += 8;
+            }
+
+            if (2 & r.wrap && 35615 === st) {
+              r.check = 0, Ct[0] = 255 & st, Ct[1] = st >>> 8 & 255, r.check = o(r.check, Ct, 2, 0), st = 0, ut = 0, r.mode = E;
+              break;
+            }
+
+            if (r.flags = 0, r.head && (r.head.done = !1), !(1 & r.wrap) || (((255 & st) << 8) + (st >> 8)) % 31) {
+              t.msg = "incorrect header check", r.mode = X;
+              break;
+            }
+
+            if ((15 & st) !== w) {
+              t.msg = "unknown compression method", r.mode = X;
+              break;
+            }
+
+            if (ut -= 4, xt = 8 + (15 & (st >>>= 4)), 0 === r.wbits) r.wbits = xt;else if (xt > r.wbits) {
+              t.msg = "invalid window size", r.mode = X;
+              break;
+            }
+            r.dmax = 1 << xt, t.adler = r.check = 1, r.mode = 512 & st ? I : B, st = 0, ut = 0;
+            break;
+
+          case E:
+            for (; ut < 16;) {
+              if (0 === ot) break t;
+              ot--, st += tt[rt++] << ut, ut += 8;
+            }
+
+            if (r.flags = st, (255 & r.flags) !== w) {
+              t.msg = "unknown compression method", r.mode = X;
+              break;
+            }
+
+            if (57344 & r.flags) {
+              t.msg = "unknown header flags set", r.mode = X;
+              break;
+            }
+
+            r.head && (r.head.text = st >> 8 & 1), 512 & r.flags && (Ct[0] = 255 & st, Ct[1] = st >>> 8 & 255, r.check = o(r.check, Ct, 2, 0)), st = 0, ut = 0, r.mode = S;
+
+          case S:
+            for (; ut < 32;) {
+              if (0 === ot) break t;
+              ot--, st += tt[rt++] << ut, ut += 8;
+            }
+
+            r.head && (r.head.time = st), 512 & r.flags && (Ct[0] = 255 & st, Ct[1] = st >>> 8 & 255, Ct[2] = st >>> 16 & 255, Ct[3] = st >>> 24 & 255, r.check = o(r.check, Ct, 4, 0)), st = 0, ut = 0, r.mode = k;
+
+          case k:
+            for (; ut < 16;) {
+              if (0 === ot) break t;
+              ot--, st += tt[rt++] << ut, ut += 8;
+            }
+
+            r.head && (r.head.xflags = 255 & st, r.head.os = st >> 8), 512 & r.flags && (Ct[0] = 255 & st, Ct[1] = st >>> 8 & 255, r.check = o(r.check, Ct, 2, 0)), st = 0, ut = 0, r.mode = A;
+
+          case A:
+            if (1024 & r.flags) {
+              for (; ut < 16;) {
+                if (0 === ot) break t;
+                ot--, st += tt[rt++] << ut, ut += 8;
+              }
+
+              r.length = st, r.head && (r.head.extra_len = st), 512 & r.flags && (Ct[0] = 255 & st, Ct[1] = st >>> 8 & 255, r.check = o(r.check, Ct, 2, 0)), st = 0, ut = 0;
+            } else r.head && (r.head.extra = null);
+
+            r.mode = C;
+
+          case C:
+            if (1024 & r.flags && ((lt = r.length) > ot && (lt = ot), lt && (r.head && (xt = r.head.extra_len - r.length, r.head.extra || (r.head.extra = new Array(r.head.extra_len)), n.arraySet(r.head.extra, tt, rt, lt, xt)), 512 & r.flags && (r.check = o(r.check, tt, lt, rt)), ot -= lt, rt += lt, r.length -= lt), r.length)) break t;
+            r.length = 0, r.mode = T;
+
+          case T:
+            if (2048 & r.flags) {
+              if (0 === ot) break t;
+              lt = 0;
+
+              do {
+                xt = tt[rt + lt++], r.head && xt && r.length < 65536 && (r.head.name += String.fromCharCode(xt));
+              } while (xt && lt < ot);
+
+              if (512 & r.flags && (r.check = o(r.check, tt, lt, rt)), ot -= lt, rt += lt, xt) break t;
+            } else r.head && (r.head.name = null);
+
+            r.length = 0, r.mode = R;
+
+          case R:
+            if (4096 & r.flags) {
+              if (0 === ot) break t;
+              lt = 0;
+
+              do {
+                xt = tt[rt + lt++], r.head && xt && r.length < 65536 && (r.head.comment += String.fromCharCode(xt));
+              } while (xt && lt < ot);
+
+              if (512 & r.flags && (r.check = o(r.check, tt, lt, rt)), ot -= lt, rt += lt, xt) break t;
+            } else r.head && (r.head.comment = null);
+
+            r.mode = O;
+
+          case O:
+            if (512 & r.flags) {
+              for (; ut < 16;) {
+                if (0 === ot) break t;
+                ot--, st += tt[rt++] << ut, ut += 8;
+              }
+
+              if (st !== (65535 & r.check)) {
+                t.msg = "header crc mismatch", r.mode = X;
+                break;
+              }
+
+              st = 0, ut = 0;
+            }
+
+            r.head && (r.head.hcrc = r.flags >> 9 & 1, r.head.done = !0), t.adler = r.check = 0, r.mode = B;
+            break;
+
+          case I:
+            for (; ut < 32;) {
+              if (0 === ot) break t;
+              ot--, st += tt[rt++] << ut, ut += 8;
+            }
+
+            t.adler = r.check = nt(st), st = 0, ut = 0, r.mode = L;
+
+          case L:
+            if (0 === r.havedict) return t.next_out = it, t.avail_out = at, t.next_in = rt, t.avail_in = ot, r.hold = st, r.bits = ut, v;
+            t.adler = r.check = 1, r.mode = B;
+
+          case B:
+            if (e === h || e === d) break t;
+
+          case P:
+            if (r.last) {
+              st >>>= 7 & ut, ut -= 7 & ut, r.mode = W;
+              break;
+            }
+
+            for (; ut < 3;) {
+              if (0 === ot) break t;
+              ot--, st += tt[rt++] << ut, ut += 8;
+            }
+
+            switch (r.last = 1 & st, ut -= 1, 3 & (st >>>= 1)) {
+              case 0:
+                r.mode = F;
+                break;
+
+              case 1:
+                if (ht(r), r.mode = D, e === d) {
+                  st >>>= 2, ut -= 2;
+                  break t;
+                }
+
+                break;
+
+              case 2:
+                r.mode = j;
+                break;
+
+              case 3:
+                t.msg = "invalid block type", r.mode = X;
+            }
+
+            st >>>= 2, ut -= 2;
+            break;
+
+          case F:
+            for (st >>>= 7 & ut, ut -= 7 & ut; ut < 32;) {
+              if (0 === ot) break t;
+              ot--, st += tt[rt++] << ut, ut += 8;
+            }
+
+            if ((65535 & st) != (st >>> 16 ^ 65535)) {
+              t.msg = "invalid stored block lengths", r.mode = X;
+              break;
+            }
+
+            if (r.length = 65535 & st, st = 0, ut = 0, r.mode = N, e === d) break t;
+
+          case N:
+            r.mode = M;
+
+          case M:
+            if (lt = r.length) {
+              if (lt > ot && (lt = ot), lt > at && (lt = at), 0 === lt) break t;
+              n.arraySet(et, tt, rt, lt, it), ot -= lt, rt += lt, at -= lt, it += lt, r.length -= lt;
+              break;
+            }
+
+            r.mode = B;
+            break;
+
+          case j:
+            for (; ut < 14;) {
+              if (0 === ot) break t;
+              ot--, st += tt[rt++] << ut, ut += 8;
+            }
+
+            if (r.nlen = 257 + (31 & st), st >>>= 5, ut -= 5, r.ndist = 1 + (31 & st), st >>>= 5, ut -= 5, r.ncode = 4 + (15 & st), st >>>= 4, ut -= 4, r.nlen > 286 || r.ndist > 30) {
+              t.msg = "too many length or distance symbols", r.mode = X;
+              break;
+            }
+
+            r.have = 0, r.mode = z;
+
+          case z:
+            for (; r.have < r.ncode;) {
+              for (; ut < 3;) {
+                if (0 === ot) break t;
+                ot--, st += tt[rt++] << ut, ut += 8;
+              }
+
+              r.lens[Tt[r.have++]] = 7 & st, st >>>= 3, ut -= 3;
+            }
+
+            for (; r.have < 19;) r.lens[Tt[r.have++]] = 0;
+
+            if (r.lencode = r.lendyn, r.lenbits = 7, St = {
+              bits: r.lenbits
+            }, Et = s(u, r.lens, 0, 19, r.lencode, 0, r.work, St), r.lenbits = St.bits, Et) {
+              t.msg = "invalid code lengths set", r.mode = X;
+              break;
+            }
+
+            r.have = 0, r.mode = U;
+
+          case U:
+            for (; r.have < r.nlen + r.ndist;) {
+              for (; yt = (At = r.lencode[st & (1 << r.lenbits) - 1]) >>> 16 & 255, mt = 65535 & At, !((vt = At >>> 24) <= ut);) {
+                if (0 === ot) break t;
+                ot--, st += tt[rt++] << ut, ut += 8;
+              }
+
+              if (mt < 16) st >>>= vt, ut -= vt, r.lens[r.have++] = mt;else {
+                if (16 === mt) {
+                  for (kt = vt + 2; ut < kt;) {
+                    if (0 === ot) break t;
+                    ot--, st += tt[rt++] << ut, ut += 8;
+                  }
+
+                  if (st >>>= vt, ut -= vt, 0 === r.have) {
+                    t.msg = "invalid bit length repeat", r.mode = X;
+                    break;
+                  }
+
+                  xt = r.lens[r.have - 1], lt = 3 + (3 & st), st >>>= 2, ut -= 2;
+                } else if (17 === mt) {
+                  for (kt = vt + 3; ut < kt;) {
+                    if (0 === ot) break t;
+                    ot--, st += tt[rt++] << ut, ut += 8;
+                  }
+
+                  ut -= vt, xt = 0, lt = 3 + (7 & (st >>>= vt)), st >>>= 3, ut -= 3;
+                } else {
+                  for (kt = vt + 7; ut < kt;) {
+                    if (0 === ot) break t;
+                    ot--, st += tt[rt++] << ut, ut += 8;
+                  }
+
+                  ut -= vt, xt = 0, lt = 11 + (127 & (st >>>= vt)), st >>>= 7, ut -= 7;
+                }
+
+                if (r.have + lt > r.nlen + r.ndist) {
+                  t.msg = "invalid bit length repeat", r.mode = X;
+                  break;
+                }
+
+                for (; lt--;) r.lens[r.have++] = xt;
+              }
+            }
+
+            if (r.mode === X) break;
+
+            if (0 === r.lens[256]) {
+              t.msg = "invalid code -- missing end-of-block", r.mode = X;
+              break;
+            }
+
+            if (r.lenbits = 9, St = {
+              bits: r.lenbits
+            }, Et = s(f, r.lens, 0, r.nlen, r.lencode, 0, r.work, St), r.lenbits = St.bits, Et) {
+              t.msg = "invalid literal/lengths set", r.mode = X;
+              break;
+            }
+
+            if (r.distbits = 6, r.distcode = r.distdyn, St = {
+              bits: r.distbits
+            }, Et = s(c, r.lens, r.nlen, r.ndist, r.distcode, 0, r.work, St), r.distbits = St.bits, Et) {
+              t.msg = "invalid distances set", r.mode = X;
+              break;
+            }
+
+            if (r.mode = D, e === d) break t;
+
+          case D:
+            r.mode = q;
+
+          case q:
+            if (ot >= 6 && at >= 258) {
+              t.next_out = it, t.avail_out = at, t.next_in = rt, t.avail_in = ot, r.hold = st, r.bits = ut, a(t, ct), it = t.next_out, et = t.output, at = t.avail_out, rt = t.next_in, tt = t.input, ot = t.avail_in, st = r.hold, ut = r.bits, r.mode === B && (r.back = -1);
+              break;
+            }
+
+            for (r.back = 0; yt = (At = r.lencode[st & (1 << r.lenbits) - 1]) >>> 16 & 255, mt = 65535 & At, !((vt = At >>> 24) <= ut);) {
+              if (0 === ot) break t;
+              ot--, st += tt[rt++] << ut, ut += 8;
+            }
+
+            if (yt && 0 == (240 & yt)) {
+              for (bt = vt, _t = yt, wt = mt; yt = (At = r.lencode[wt + ((st & (1 << bt + _t) - 1) >> bt)]) >>> 16 & 255, mt = 65535 & At, !(bt + (vt = At >>> 24) <= ut);) {
+                if (0 === ot) break t;
+                ot--, st += tt[rt++] << ut, ut += 8;
+              }
+
+              st >>>= bt, ut -= bt, r.back += bt;
+            }
+
+            if (st >>>= vt, ut -= vt, r.back += vt, r.length = mt, 0 === yt) {
+              r.mode = Y;
+              break;
+            }
+
+            if (32 & yt) {
+              r.back = -1, r.mode = B;
+              break;
+            }
+
+            if (64 & yt) {
+              t.msg = "invalid literal/length code", r.mode = X;
+              break;
+            }
+
+            r.extra = 15 & yt, r.mode = Z;
+
+          case Z:
+            if (r.extra) {
+              for (kt = r.extra; ut < kt;) {
+                if (0 === ot) break t;
+                ot--, st += tt[rt++] << ut, ut += 8;
+              }
+
+              r.length += st & (1 << r.extra) - 1, st >>>= r.extra, ut -= r.extra, r.back += r.extra;
+            }
+
+            r.was = r.length, r.mode = H;
+
+          case H:
+            for (; yt = (At = r.distcode[st & (1 << r.distbits) - 1]) >>> 16 & 255, mt = 65535 & At, !((vt = At >>> 24) <= ut);) {
+              if (0 === ot) break t;
+              ot--, st += tt[rt++] << ut, ut += 8;
+            }
+
+            if (0 == (240 & yt)) {
+              for (bt = vt, _t = yt, wt = mt; yt = (At = r.distcode[wt + ((st & (1 << bt + _t) - 1) >> bt)]) >>> 16 & 255, mt = 65535 & At, !(bt + (vt = At >>> 24) <= ut);) {
+                if (0 === ot) break t;
+                ot--, st += tt[rt++] << ut, ut += 8;
+              }
+
+              st >>>= bt, ut -= bt, r.back += bt;
+            }
+
+            if (st >>>= vt, ut -= vt, r.back += vt, 64 & yt) {
+              t.msg = "invalid distance code", r.mode = X;
+              break;
+            }
+
+            r.offset = mt, r.extra = 15 & yt, r.mode = V;
+
+          case V:
+            if (r.extra) {
+              for (kt = r.extra; ut < kt;) {
+                if (0 === ot) break t;
+                ot--, st += tt[rt++] << ut, ut += 8;
+              }
+
+              r.offset += st & (1 << r.extra) - 1, st >>>= r.extra, ut -= r.extra, r.back += r.extra;
+            }
+
+            if (r.offset > r.dmax) {
+              t.msg = "invalid distance too far back", r.mode = X;
+              break;
+            }
+
+            r.mode = G;
+
+          case G:
+            if (0 === at) break t;
+
+            if (lt = ct - at, r.offset > lt) {
+              if ((lt = r.offset - lt) > r.whave && r.sane) {
+                t.msg = "invalid distance too far back", r.mode = X;
+                break;
+              }
+
+              lt > r.wnext ? (lt -= r.wnext, pt = r.wsize - lt) : pt = r.wnext - lt, lt > r.length && (lt = r.length), gt = r.window;
+            } else gt = et, pt = it - r.offset, lt = r.length;
+
+            lt > at && (lt = at), at -= lt, r.length -= lt;
+
+            do {
+              et[it++] = gt[pt++];
+            } while (--lt);
+
+            0 === r.length && (r.mode = q);
+            break;
+
+          case Y:
+            if (0 === at) break t;
+            et[it++] = r.length, at--, r.mode = q;
+            break;
+
+          case W:
+            if (r.wrap) {
+              for (; ut < 32;) {
+                if (0 === ot) break t;
+                ot--, st |= tt[rt++] << ut, ut += 8;
+              }
+
+              if (ct -= at, t.total_out += ct, r.total += ct, ct && (t.adler = r.check = r.flags ? o(r.check, et, ct, it - ct) : i(r.check, et, ct, it - ct)), ct = at, (r.flags ? st : nt(st)) !== r.check) {
+                t.msg = "incorrect data check", r.mode = X;
+                break;
+              }
+
+              st = 0, ut = 0;
+            }
+
+            r.mode = K;
+
+          case K:
+            if (r.wrap && r.flags) {
+              for (; ut < 32;) {
+                if (0 === ot) break t;
+                ot--, st += tt[rt++] << ut, ut += 8;
+              }
+
+              if (st !== (4294967295 & r.total)) {
+                t.msg = "incorrect length check", r.mode = X;
+                break;
+              }
+
+              st = 0, ut = 0;
+            }
+
+            r.mode = Q;
+
+          case Q:
+            Et = g;
+            break t;
+
+          case X:
+            Et = m;
+            break t;
+
+          case $:
+            return b;
+
+          case J:
+          default:
+            return y;
+        }
+
+        return t.next_out = it, t.avail_out = at, t.next_in = rt, t.avail_in = ot, r.hold = st, r.bits = ut, (r.wsize || ct !== t.avail_out && r.mode < X && (r.mode < W || e !== l)) && dt(t, t.output, t.next_out, ct - t.avail_out) ? (r.mode = $, b) : (ft -= t.avail_in, ct -= t.avail_out, t.total_in += ft, t.total_out += ct, r.total += ct, r.wrap && ct && (t.adler = r.check = r.flags ? o(r.check, et, ct, t.next_out - ct) : i(r.check, et, ct, t.next_out - ct)), t.data_type = r.bits + (r.last ? 64 : 0) + (r.mode === B ? 128 : 0) + (r.mode === D || r.mode === N ? 256 : 0), (0 === ft && 0 === ct || e === l) && Et === p && (Et = _), Et);
+      }, e.inflateEnd = function (t) {
+        if (!t || !t.state) return y;
+        var e = t.state;
+        return e.window && (e.window = null), t.state = null, p;
+      }, e.inflateGetHeader = function (t, e) {
+        var r;
+        return t && t.state ? 0 == (2 & (r = t.state).wrap) ? y : (r.head = e, e.done = !1, p) : y;
+      }, e.inflateSetDictionary = function (t, e) {
+        var r,
+            n = e.length;
+        return t && t.state ? 0 !== (r = t.state).wrap && r.mode !== L ? y : r.mode === L && i(1, e, n, 0) !== r.check ? m : dt(t, e, n, n) ? (r.mode = $, b) : (r.havedict = 1, p) : y;
+      }, e.inflateInfo = "pako inflate (from Nodeca project)";
+    }, function (t, e, r) {
+
+      t.exports = function (t, e) {
+        var r, n, i, o, a, s, u, f, c, l, h, d, p, g, v, y, m, b, _, w, x, E, S, k, A;
+
+        r = t.state, n = t.next_in, k = t.input, i = n + (t.avail_in - 5), o = t.next_out, A = t.output, a = o - (e - t.avail_out), s = o + (t.avail_out - 257), u = r.dmax, f = r.wsize, c = r.whave, l = r.wnext, h = r.window, d = r.hold, p = r.bits, g = r.lencode, v = r.distcode, y = (1 << r.lenbits) - 1, m = (1 << r.distbits) - 1;
+
+        t: do {
+          p < 15 && (d += k[n++] << p, p += 8, d += k[n++] << p, p += 8), b = g[d & y];
+
+          e: for (;;) {
+            if (d >>>= _ = b >>> 24, p -= _, 0 === (_ = b >>> 16 & 255)) A[o++] = 65535 & b;else {
+              if (!(16 & _)) {
+                if (0 == (64 & _)) {
+                  b = g[(65535 & b) + (d & (1 << _) - 1)];
+                  continue e;
+                }
+
+                if (32 & _) {
+                  r.mode = 12;
+                  break t;
+                }
+
+                t.msg = "invalid literal/length code", r.mode = 30;
+                break t;
+              }
+
+              w = 65535 & b, (_ &= 15) && (p < _ && (d += k[n++] << p, p += 8), w += d & (1 << _) - 1, d >>>= _, p -= _), p < 15 && (d += k[n++] << p, p += 8, d += k[n++] << p, p += 8), b = v[d & m];
+
+              r: for (;;) {
+                if (d >>>= _ = b >>> 24, p -= _, !(16 & (_ = b >>> 16 & 255))) {
+                  if (0 == (64 & _)) {
+                    b = v[(65535 & b) + (d & (1 << _) - 1)];
+                    continue r;
+                  }
+
+                  t.msg = "invalid distance code", r.mode = 30;
+                  break t;
+                }
+
+                if (x = 65535 & b, p < (_ &= 15) && (d += k[n++] << p, (p += 8) < _ && (d += k[n++] << p, p += 8)), (x += d & (1 << _) - 1) > u) {
+                  t.msg = "invalid distance too far back", r.mode = 30;
+                  break t;
+                }
+
+                if (d >>>= _, p -= _, x > (_ = o - a)) {
+                  if ((_ = x - _) > c && r.sane) {
+                    t.msg = "invalid distance too far back", r.mode = 30;
+                    break t;
+                  }
+
+                  if (E = 0, S = h, 0 === l) {
+                    if (E += f - _, _ < w) {
+                      w -= _;
+
+                      do {
+                        A[o++] = h[E++];
+                      } while (--_);
+
+                      E = o - x, S = A;
+                    }
+                  } else if (l < _) {
+                    if (E += f + l - _, (_ -= l) < w) {
+                      w -= _;
+
+                      do {
+                        A[o++] = h[E++];
+                      } while (--_);
+
+                      if (E = 0, l < w) {
+                        w -= _ = l;
+
+                        do {
+                          A[o++] = h[E++];
+                        } while (--_);
+
+                        E = o - x, S = A;
+                      }
+                    }
+                  } else if (E += l - _, _ < w) {
+                    w -= _;
+
+                    do {
+                      A[o++] = h[E++];
+                    } while (--_);
+
+                    E = o - x, S = A;
+                  }
+
+                  for (; w > 2;) A[o++] = S[E++], A[o++] = S[E++], A[o++] = S[E++], w -= 3;
+
+                  w && (A[o++] = S[E++], w > 1 && (A[o++] = S[E++]));
+                } else {
+                  E = o - x;
+
+                  do {
+                    A[o++] = A[E++], A[o++] = A[E++], A[o++] = A[E++], w -= 3;
+                  } while (w > 2);
+
+                  w && (A[o++] = A[E++], w > 1 && (A[o++] = A[E++]));
+                }
+
+                break;
+              }
+            }
+            break;
+          }
+        } while (n < i && o < s);
+
+        n -= w = p >> 3, d &= (1 << (p -= w << 3)) - 1, t.next_in = n, t.next_out = o, t.avail_in = n < i ? i - n + 5 : 5 - (n - i), t.avail_out = o < s ? s - o + 257 : 257 - (o - s), r.hold = d, r.bits = p;
+      };
+    }, function (t, e, r) {
+
+      var n = r(72),
+          i = [3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31, 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0],
+          o = [16, 16, 16, 16, 16, 16, 16, 16, 17, 17, 17, 17, 18, 18, 18, 18, 19, 19, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 16, 72, 78],
+          a = [1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193, 257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145, 8193, 12289, 16385, 24577, 0, 0],
+          s = [16, 16, 16, 16, 17, 17, 18, 18, 19, 19, 20, 20, 21, 21, 22, 22, 23, 23, 24, 24, 25, 25, 26, 26, 27, 27, 28, 28, 29, 29, 64, 64];
+
+      t.exports = function (t, e, r, u, f, c, l, h) {
+        var d,
+            p,
+            g,
+            v,
+            y,
+            m,
+            b,
+            _,
+            w,
+            x = h.bits,
+            E = 0,
+            S = 0,
+            k = 0,
+            A = 0,
+            C = 0,
+            T = 0,
+            R = 0,
+            O = 0,
+            I = 0,
+            L = 0,
+            B = null,
+            P = 0,
+            F = new n.Buf16(16),
+            N = new n.Buf16(16),
+            M = null,
+            j = 0;
+
+        for (E = 0; E <= 15; E++) F[E] = 0;
+
+        for (S = 0; S < u; S++) F[e[r + S]]++;
+
+        for (C = x, A = 15; A >= 1 && 0 === F[A]; A--);
+
+        if (C > A && (C = A), 0 === A) return f[c++] = 20971520, f[c++] = 20971520, h.bits = 1, 0;
+
+        for (k = 1; k < A && 0 === F[k]; k++);
+
+        for (C < k && (C = k), O = 1, E = 1; E <= 15; E++) if (O <<= 1, (O -= F[E]) < 0) return -1;
+
+        if (O > 0 && (0 === t || 1 !== A)) return -1;
+
+        for (N[1] = 0, E = 1; E < 15; E++) N[E + 1] = N[E] + F[E];
+
+        for (S = 0; S < u; S++) 0 !== e[r + S] && (l[N[e[r + S]]++] = S);
+
+        if (0 === t ? (B = M = l, m = 19) : 1 === t ? (B = i, P -= 257, M = o, j -= 257, m = 256) : (B = a, M = s, m = -1), L = 0, S = 0, E = k, y = c, T = C, R = 0, g = -1, v = (I = 1 << C) - 1, 1 === t && I > 852 || 2 === t && I > 592) return 1;
+
+        for (;;) {
+          b = E - R, l[S] < m ? (_ = 0, w = l[S]) : l[S] > m ? (_ = M[j + l[S]], w = B[P + l[S]]) : (_ = 96, w = 0), d = 1 << E - R, k = p = 1 << T;
+
+          do {
+            f[y + (L >> R) + (p -= d)] = b << 24 | _ << 16 | w | 0;
+          } while (0 !== p);
+
+          for (d = 1 << E - 1; L & d;) d >>= 1;
+
+          if (0 !== d ? (L &= d - 1, L += d) : L = 0, S++, 0 == --F[E]) {
+            if (E === A) break;
+            E = e[r + l[S]];
+          }
+
+          if (E > C && (L & v) !== g) {
+            for (0 === R && (R = C), y += k, O = 1 << (T = E - R); T + R < A && !((O -= F[T + R]) <= 0);) T++, O <<= 1;
+
+            if (I += 1 << T, 1 === t && I > 852 || 2 === t && I > 592) return 1;
+            f[g = L & v] = C << 24 | T << 16 | y - c | 0;
+          }
+        }
+
+        return 0 !== L && (f[y + L] = E - R << 24 | 64 << 16 | 0), h.bits = C, 0;
+      };
+    }, function (t, e, r) {
+
+      t.exports = {
+        Z_NO_FLUSH: 0,
+        Z_PARTIAL_FLUSH: 1,
+        Z_SYNC_FLUSH: 2,
+        Z_FULL_FLUSH: 3,
+        Z_FINISH: 4,
+        Z_BLOCK: 5,
+        Z_TREES: 6,
+        Z_OK: 0,
+        Z_STREAM_END: 1,
+        Z_NEED_DICT: 2,
+        Z_ERRNO: -1,
+        Z_STREAM_ERROR: -2,
+        Z_DATA_ERROR: -3,
+        Z_BUF_ERROR: -5,
+        Z_NO_COMPRESSION: 0,
+        Z_BEST_SPEED: 1,
+        Z_BEST_COMPRESSION: 9,
+        Z_DEFAULT_COMPRESSION: -1,
+        Z_FILTERED: 1,
+        Z_HUFFMAN_ONLY: 2,
+        Z_RLE: 3,
+        Z_FIXED: 4,
+        Z_DEFAULT_STRATEGY: 0,
+        Z_BINARY: 0,
+        Z_TEXT: 1,
+        Z_UNKNOWN: 2,
+        Z_DEFLATED: 8
+      };
+    }, function (t, e, r) {
+      var n = r(19).Buffer,
+          i = [0, 1996959894, 3993919788, 2567524794, 124634137, 1886057615, 3915621685, 2657392035, 249268274, 2044508324, 3772115230, 2547177864, 162941995, 2125561021, 3887607047, 2428444049, 498536548, 1789927666, 4089016648, 2227061214, 450548861, 1843258603, 4107580753, 2211677639, 325883990, 1684777152, 4251122042, 2321926636, 335633487, 1661365465, 4195302755, 2366115317, 997073096, 1281953886, 3579855332, 2724688242, 1006888145, 1258607687, 3524101629, 2768942443, 901097722, 1119000684, 3686517206, 2898065728, 853044451, 1172266101, 3705015759, 2882616665, 651767980, 1373503546, 3369554304, 3218104598, 565507253, 1454621731, 3485111705, 3099436303, 671266974, 1594198024, 3322730930, 2970347812, 795835527, 1483230225, 3244367275, 3060149565, 1994146192, 31158534, 2563907772, 4023717930, 1907459465, 112637215, 2680153253, 3904427059, 2013776290, 251722036, 2517215374, 3775830040, 2137656763, 141376813, 2439277719, 3865271297, 1802195444, 476864866, 2238001368, 4066508878, 1812370925, 453092731, 2181625025, 4111451223, 1706088902, 314042704, 2344532202, 4240017532, 1658658271, 366619977, 2362670323, 4224994405, 1303535960, 984961486, 2747007092, 3569037538, 1256170817, 1037604311, 2765210733, 3554079995, 1131014506, 879679996, 2909243462, 3663771856, 1141124467, 855842277, 2852801631, 3708648649, 1342533948, 654459306, 3188396048, 3373015174, 1466479909, 544179635, 3110523913, 3462522015, 1591671054, 702138776, 2966460450, 3352799412, 1504918807, 783551873, 3082640443, 3233442989, 3988292384, 2596254646, 62317068, 1957810842, 3939845945, 2647816111, 81470997, 1943803523, 3814918930, 2489596804, 225274430, 2053790376, 3826175755, 2466906013, 167816743, 2097651377, 4027552580, 2265490386, 503444072, 1762050814, 4150417245, 2154129355, 426522225, 1852507879, 4275313526, 2312317920, 282753626, 1742555852, 4189708143, 2394877945, 397917763, 1622183637, 3604390888, 2714866558, 953729732, 1340076626, 3518719985, 2797360999, 1068828381, 1219638859, 3624741850, 2936675148, 906185462, 1090812512, 3747672003, 2825379669, 829329135, 1181335161, 3412177804, 3160834842, 628085408, 1382605366, 3423369109, 3138078467, 570562233, 1426400815, 3317316542, 2998733608, 733239954, 1555261956, 3268935591, 3050360625, 752459403, 1541320221, 2607071920, 3965973030, 1969922972, 40735498, 2617837225, 3943577151, 1913087877, 83908371, 2512341634, 3803740692, 2075208622, 213261112, 2463272603, 3855990285, 2094854071, 198958881, 2262029012, 4057260610, 1759359992, 534414190, 2176718541, 4139329115, 1873836001, 414664567, 2282248934, 4279200368, 1711684554, 285281116, 2405801727, 4167216745, 1634467795, 376229701, 2685067896, 3608007406, 1308918612, 956543938, 2808555105, 3495958263, 1231636301, 1047427035, 2932959818, 3654703836, 1088359270, 936918e3, 2847714899, 3736837829, 1202900863, 817233897, 3183342108, 3401237130, 1404277552, 615818150, 3134207493, 3453421203, 1423857449, 601450431, 3009837614, 3294710456, 1567103746, 711928724, 3020668471, 3272380065, 1510334235, 755167117];
+
+      function o(t) {
+        if (n.isBuffer(t)) return t;
+        var e = "function" == typeof n.alloc && "function" == typeof n.from;
+        if ("number" == typeof t) return e ? n.alloc(t) : new n(t);
+        if ("string" == typeof t) return e ? n.from(t) : new n(t);
+        throw new Error("input must be buffer, number, or string, received " + typeof t);
+      }
+
+      function a(t, e) {
+        t = o(t), n.isBuffer(e) && (e = e.readUInt32BE(0));
+
+        for (var r = -1 ^ ~~e, a = 0; a < t.length; a++) r = i[255 & (r ^ t[a])] ^ r >>> 8;
+
+        return -1 ^ r;
+      }
+
+      function s() {
+        return t = a.apply(null, arguments), (e = o(4)).writeInt32BE(t, 0), e;
+        var t, e;
+      }
+
+      "undefined" != typeof Int32Array && (i = new Int32Array(i)), s.signed = function () {
+        return a.apply(null, arguments);
+      }, s.unsigned = function () {
+        return a.apply(null, arguments) >>> 0;
+      }, t.exports = s;
+    }, function (t, e, r) {
+      var n = r(226),
+          i = r(229);
+
+      function o(t) {
+        return (o = "function" == typeof i && "symbol" == typeof n ? function (t) {
+          return typeof t;
+        } : function (t) {
+          return t && "function" == typeof i && t.constructor === i && t !== i.prototype ? "symbol" : typeof t;
+        })(t);
+      }
+
+      function a(e) {
+        return "function" == typeof i && "symbol" === o(n) ? t.exports = a = function (t) {
+          return o(t);
+        } : t.exports = a = function (t) {
+          return t && "function" == typeof i && t.constructor === i && t !== i.prototype ? "symbol" : o(t);
+        }, a(e);
+      }
+
+      t.exports = a;
+    }, function (t, e, r) {
+      t.exports = r(227);
+    }, function (t, e, r) {
+      t.exports = r(228);
+    }, function (t, e, r) {
+      r(136), r(46), r(41);
+      var n = r(95);
+      t.exports = n.f("iterator");
+    }, function (t, e, r) {
+      t.exports = r(230);
+    }, function (t, e, r) {
+      t.exports = r(231), r(249), r(250), r(251), r(252), r(253);
+    }, function (t, e, r) {
+      r(114), r(88), r(232), r(234), r(235), r(236), r(237), r(136), r(238), r(239), r(240), r(241), r(242), r(243), r(244), r(245), r(246), r(247), r(248);
+      var n = r(3);
+      t.exports = n.Symbol;
+    }, function (t, e, r) {
+
+      var n = r(0),
+          i = r(13),
+          o = r(4),
+          a = r(17),
+          s = r(110),
+          u = r(12),
+          f = r(24),
+          c = r(53),
+          l = r(14),
+          h = r(2),
+          d = r(22),
+          p = r(28),
+          g = r(62),
+          v = r(43),
+          y = r(44),
+          m = r(51),
+          b = r(137),
+          _ = r(233),
+          w = r(138),
+          x = r(81),
+          E = r(21),
+          S = r(65),
+          k = r(20),
+          A = r(52),
+          C = r(61),
+          T = r(63),
+          R = r(50),
+          O = r(64),
+          I = r(6),
+          L = r(95),
+          B = r(11),
+          P = r(36),
+          F = r(42),
+          N = r(45).forEach,
+          M = T("hidden"),
+          j = I("toPrimitive"),
+          z = F.set,
+          U = F.getterFor("Symbol"),
+          D = Object.prototype,
+          q = i.Symbol,
+          Z = i.JSON,
+          H = Z && Z.stringify,
+          V = x.f,
+          G = E.f,
+          Y = _.f,
+          W = S.f,
+          K = C("symbols"),
+          Q = C("op-symbols"),
+          X = C("string-to-symbol-registry"),
+          $ = C("symbol-to-string-registry"),
+          J = C("wks"),
+          tt = i.QObject,
+          et = !tt || !tt.prototype || !tt.prototype.findChild,
+          rt = a && u(function () {
+        return 7 != y(G({}, "a", {
+          get: function () {
+            return G(this, "a", {
+              value: 7
+            }).a;
+          }
+        })).a;
+      }) ? function (t, e, r) {
+        var n = V(D, e);
+        n && delete D[e], G(t, e, r), n && t !== D && G(D, e, n);
+      } : G,
+          nt = function (t, e) {
+        var r = K[t] = y(q.prototype);
+        return z(r, {
+          type: "Symbol",
+          tag: t,
+          description: e
+        }), a || (r.description = e), r;
+      },
+          it = s && "symbol" == typeof q.iterator ? function (t) {
+        return "symbol" == typeof t;
+      } : function (t) {
+        return Object(t) instanceof q;
+      },
+          ot = function (t, e, r) {
+        t === D && ot(Q, e, r), h(t);
+        var n = g(e, !0);
+        return h(r), f(K, n) ? (r.enumerable ? (f(t, M) && t[M][n] && (t[M][n] = !1), r = y(r, {
+          enumerable: v(0, !1)
+        })) : (f(t, M) || G(t, M, v(1, {})), t[M][n] = !0), rt(t, n, r)) : G(t, n, r);
+      },
+          at = function (t, e) {
+        h(t);
+        var r = p(e),
+            n = m(r).concat(ct(r));
+        return N(n, function (e) {
+          a && !st.call(r, e) || ot(t, e, r[e]);
+        }), t;
+      },
+          st = function (t) {
+        var e = g(t, !0),
+            r = W.call(this, e);
+        return !(this === D && f(K, e) && !f(Q, e)) && (!(r || !f(this, e) || !f(K, e) || f(this, M) && this[M][e]) || r);
+      },
+          ut = function (t, e) {
+        var r = p(t),
+            n = g(e, !0);
+
+        if (r !== D || !f(K, n) || f(Q, n)) {
+          var i = V(r, n);
+          return !i || !f(K, n) || f(r, M) && r[M][n] || (i.enumerable = !0), i;
+        }
+      },
+          ft = function (t) {
+        var e = Y(p(t)),
+            r = [];
+        return N(e, function (t) {
+          f(K, t) || f(R, t) || r.push(t);
+        }), r;
+      },
+          ct = function (t) {
+        var e = t === D,
+            r = Y(e ? Q : p(t)),
+            n = [];
+        return N(r, function (t) {
+          !f(K, t) || e && !f(D, t) || n.push(K[t]);
+        }), n;
+      };
+
+      s || (A((q = function () {
+        if (this instanceof q) throw TypeError("Symbol is not a constructor");
+
+        var t = arguments.length && void 0 !== arguments[0] ? String(arguments[0]) : void 0,
+            e = O(t),
+            r = function (t) {
+          this === D && r.call(Q, t), f(this, M) && f(this[M], e) && (this[M][e] = !1), rt(this, e, v(1, t));
+        };
+
+        return a && et && rt(D, e, {
+          configurable: !0,
+          set: r
+        }), nt(e, t);
+      }).prototype, "toString", function () {
+        return U(this).tag;
+      }), S.f = st, E.f = ot, x.f = ut, b.f = _.f = ft, w.f = ct, a && (G(q.prototype, "description", {
+        configurable: !0,
+        get: function () {
+          return U(this).description;
+        }
+      }), o || A(D, "propertyIsEnumerable", st, {
+        unsafe: !0
+      })), L.f = function (t) {
+        return nt(I(t), t);
+      }), n({
+        global: !0,
+        wrap: !0,
+        forced: !s,
+        sham: !s
+      }, {
+        Symbol: q
+      }), N(m(J), function (t) {
+        B(t);
+      }), n({
+        target: "Symbol",
+        stat: !0,
+        forced: !s
+      }, {
+        for: function (t) {
+          var e = String(t);
+          if (f(X, e)) return X[e];
+          var r = q(e);
+          return X[e] = r, $[r] = e, r;
+        },
+        keyFor: function (t) {
+          if (!it(t)) throw TypeError(t + " is not a symbol");
+          if (f($, t)) return $[t];
+        },
+        useSetter: function () {
+          et = !0;
+        },
+        useSimple: function () {
+          et = !1;
+        }
+      }), n({
+        target: "Object",
+        stat: !0,
+        forced: !s,
+        sham: !a
+      }, {
+        create: function (t, e) {
+          return void 0 === e ? y(t) : at(y(t), e);
+        },
+        defineProperty: ot,
+        defineProperties: at,
+        getOwnPropertyDescriptor: ut
+      }), n({
+        target: "Object",
+        stat: !0,
+        forced: !s
+      }, {
+        getOwnPropertyNames: ft,
+        getOwnPropertySymbols: ct
+      }), n({
+        target: "Object",
+        stat: !0,
+        forced: u(function () {
+          w.f(1);
+        })
+      }, {
+        getOwnPropertySymbols: function (t) {
+          return w.f(d(t));
+        }
+      }), Z && n({
+        target: "JSON",
+        stat: !0,
+        forced: !s || u(function () {
+          var t = q();
+          return "[null]" != H([t]) || "{}" != H({
+            a: t
+          }) || "{}" != H(Object(t));
+        })
+      }, {
+        stringify: function (t) {
+          for (var e, r, n = [t], i = 1; arguments.length > i;) n.push(arguments[i++]);
+
+          if (r = e = n[1], (l(e) || void 0 !== t) && !it(t)) return c(e) || (e = function (t, e) {
+            if ("function" == typeof r && (e = r.call(this, t, e)), !it(e)) return e;
+          }), n[1] = e, H.apply(Z, n);
+        }
+      }), q.prototype[j] || k(q.prototype, j, q.prototype.valueOf), P(q, "Symbol"), R[M] = !0;
+    }, function (t, e, r) {
+      var n = r(28),
+          i = r(137).f,
+          o = {}.toString,
+          a = "object" == typeof window && window && Object.getOwnPropertyNames ? Object.getOwnPropertyNames(window) : [];
+
+      t.exports.f = function (t) {
+        return a && "[object Window]" == o.call(t) ? function (t) {
+          try {
+            return i(t);
+          } catch (t) {
+            return a.slice();
+          }
+        }(t) : i(n(t));
+      };
+    }, function (t, e, r) {
+      r(11)("asyncIterator");
+    }, function (t, e) {}, function (t, e, r) {
+      r(11)("hasInstance");
+    }, function (t, e, r) {
+      r(11)("isConcatSpreadable");
+    }, function (t, e, r) {
+      r(11)("match");
+    }, function (t, e, r) {
+      r(11)("matchAll");
+    }, function (t, e, r) {
+      r(11)("replace");
+    }, function (t, e, r) {
+      r(11)("search");
+    }, function (t, e, r) {
+      r(11)("species");
+    }, function (t, e, r) {
+      r(11)("split");
+    }, function (t, e, r) {
+      r(11)("toPrimitive");
+    }, function (t, e, r) {
+      r(11)("toStringTag");
+    }, function (t, e, r) {
+      r(11)("unscopables");
+    }, function (t, e, r) {
+      r(36)(Math, "Math", !0);
+    }, function (t, e, r) {
+      var n = r(13);
+      r(36)(n.JSON, "JSON", !0);
+    }, function (t, e, r) {
+      r(11)("asyncDispose");
+    }, function (t, e, r) {
+      r(11)("dispose");
+    }, function (t, e, r) {
+      r(11)("observable");
+    }, function (t, e, r) {
+      r(11)("patternMatch");
+    }, function (t, e, r) {
+      r(11)("replaceAll");
+    }, function (t, e) {
+      t.exports = function (t) {
+        if (void 0 === t) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+        return t;
+      };
+    }, function (t, e, r) {
+      t.exports = r(256);
+    }, function (t, e, r) {
+      t.exports = r(257);
+    }, function (t, e, r) {
+      r(258);
+      var n = r(3);
+      t.exports = n.Object.getPrototypeOf;
+    }, function (t, e, r) {
+      var n = r(0),
+          i = r(12),
+          o = r(22),
+          a = r(66),
+          s = r(109);
+      n({
+        target: "Object",
+        stat: !0,
+        forced: i(function () {
+          a(1);
+        }),
+        sham: !s
+      }, {
+        getPrototypeOf: function (t) {
+          return a(o(t));
+        }
+      });
+    }, function (t, e, r) {
+      t.exports = r(260);
+    }, function (t, e, r) {
+      r(261);
+      var n = r(3);
+      t.exports = n.Object.setPrototypeOf;
+    }, function (t, e, r) {
+      r(0)({
+        target: "Object",
+        stat: !0
+      }, {
+        setPrototypeOf: r(86)
+      });
+    }, function (t, e, r) {
+      t.exports = r(263);
+    }, function (t, e, r) {
+      r(264);
+      var n = r(3).Object;
+
+      t.exports = function (t, e) {
+        return n.create(t, e);
+      };
+    }, function (t, e, r) {
+      r(0)({
+        target: "Object",
+        stat: !0,
+        sham: !r(17)
+      }, {
+        create: r(44)
+      });
+    }, function (t, e, r) {
+      var n = r(140),
+          i = r(266),
+          o = r(27),
+          a = r(96),
+          s = r(295),
+          u = r(300);
+
+      function f(e) {
+        var r = "function" == typeof i ? new i() : void 0;
+        return t.exports = f = function (t) {
+          if (null === t || !s(t)) return t;
+          if ("function" != typeof t) throw new TypeError("Super expression must either be null or a function");
+
+          if (void 0 !== r) {
+            if (r.has(t)) return r.get(t);
+            r.set(t, e);
+          }
+
+          function e() {
+            return u(t, arguments, o(this).constructor);
+          }
+
+          return e.prototype = n(t.prototype, {
+            constructor: {
+              value: e,
+              enumerable: !1,
+              writable: !0,
+              configurable: !0
+            }
+          }), a(e, t);
+        }, f(e);
+      }
+
+      t.exports = f;
+    }, function (t, e, r) {
+      t.exports = r(267);
+    }, function (t, e, r) {
+      t.exports = r(268), r(273), r(275), r(277), r(279), r(280), r(281), r(282), r(283), r(284), r(286), r(287), r(288), r(289), r(290), r(291), r(292), r(293), r(294);
+    }, function (t, e, r) {
+      r(269), r(88), r(46), r(41);
+      var n = r(3);
+      t.exports = n.Map;
+    }, function (t, e, r) {
+
+      var n = r(270),
+          i = r(272);
+      t.exports = n("Map", function (t) {
+        return function () {
+          return t(this, arguments.length ? arguments[0] : void 0);
+        };
+      }, i, !0);
+    }, function (t, e, r) {
+
+      var n = r(0),
+          i = r(13),
+          o = r(141),
+          a = r(12),
+          s = r(20),
+          u = r(8),
+          f = r(89),
+          c = r(14),
+          l = r(36),
+          h = r(21).f,
+          d = r(45).forEach,
+          p = r(17),
+          g = r(42),
+          v = g.set,
+          y = g.getterFor;
+
+      t.exports = function (t, e, r, g, m) {
+        var b,
+            _ = i[t],
+            w = _ && _.prototype,
+            x = g ? "set" : "add",
+            E = {};
+
+        if (p && "function" == typeof _ && (m || w.forEach && !a(function () {
+          new _().entries().next();
+        }))) {
+          b = e(function (e, r) {
+            v(f(e, b, t), {
+              type: t,
+              collection: new _()
+            }), null != r && u(r, e[x], e, g);
+          });
+          var S = y(t);
+          d(["add", "clear", "delete", "forEach", "get", "has", "set", "keys", "values", "entries"], function (t) {
+            var e = "add" == t || "set" == t;
+            t in w && (!m || "clear" != t) && s(b.prototype, t, function (r, n) {
+              var i = S(this).collection;
+              if (!e && m && !c(r)) return "get" == t && void 0;
+              var o = i[t](0 === r ? 0 : r, n);
+              return e ? this : o;
+            });
+          }), m || h(b.prototype, "size", {
+            get: function () {
+              return S(this).collection.size;
+            }
+          });
+        } else b = r.getConstructor(e, t, g, x), o.REQUIRED = !0;
+
+        return l(b, t, !1, !0), E[t] = b, n({
+          global: !0,
+          forced: !0
+        }, E), m || r.setStrong(b, t, g), b;
+      };
+    }, function (t, e, r) {
+      var n = r(12);
+      t.exports = !n(function () {
+        return Object.isExtensible(Object.preventExtensions({}));
+      });
+    }, function (t, e, r) {
+
+      var n = r(21).f,
+          i = r(44),
+          o = r(117),
+          a = r(15),
+          s = r(89),
+          u = r(8),
+          f = r(80),
+          c = r(118),
+          l = r(17),
+          h = r(141).fastKey,
+          d = r(42),
+          p = d.set,
+          g = d.getterFor;
+      t.exports = {
+        getConstructor: function (t, e, r, f) {
+          var c = t(function (t, n) {
+            s(t, c, e), p(t, {
+              type: e,
+              index: i(null),
+              first: void 0,
+              last: void 0,
+              size: 0
+            }), l || (t.size = 0), null != n && u(n, t[f], t, r);
+          }),
+              d = g(e),
+              v = function (t, e, r) {
+            var n,
+                i,
+                o = d(t),
+                a = y(t, e);
+            return a ? a.value = r : (o.last = a = {
+              index: i = h(e, !0),
+              key: e,
+              value: r,
+              previous: n = o.last,
+              next: void 0,
+              removed: !1
+            }, o.first || (o.first = a), n && (n.next = a), l ? o.size++ : t.size++, "F" !== i && (o.index[i] = a)), t;
+          },
+              y = function (t, e) {
+            var r,
+                n = d(t),
+                i = h(e);
+            if ("F" !== i) return n.index[i];
+
+            for (r = n.first; r; r = r.next) if (r.key == e) return r;
+          };
+
+          return o(c.prototype, {
+            clear: function () {
+              for (var t = d(this), e = t.index, r = t.first; r;) r.removed = !0, r.previous && (r.previous = r.previous.next = void 0), delete e[r.index], r = r.next;
+
+              t.first = t.last = void 0, l ? t.size = 0 : this.size = 0;
+            },
+            delete: function (t) {
+              var e = d(this),
+                  r = y(this, t);
+
+              if (r) {
+                var n = r.next,
+                    i = r.previous;
+                delete e.index[r.index], r.removed = !0, i && (i.next = n), n && (n.previous = i), e.first == r && (e.first = n), e.last == r && (e.last = i), l ? e.size-- : this.size--;
+              }
+
+              return !!r;
+            },
+            forEach: function (t) {
+              for (var e, r = d(this), n = a(t, arguments.length > 1 ? arguments[1] : void 0, 3); e = e ? e.next : r.first;) for (n(e.value, e.key, this); e && e.removed;) e = e.previous;
+            },
+            has: function (t) {
+              return !!y(this, t);
+            }
+          }), o(c.prototype, r ? {
+            get: function (t) {
+              var e = y(this, t);
+              return e && e.value;
+            },
+            set: function (t, e) {
+              return v(this, 0 === t ? 0 : t, e);
+            }
+          } : {
+            add: function (t) {
+              return v(this, t = 0 === t ? 0 : t, t);
+            }
+          }), l && n(c.prototype, "size", {
+            get: function () {
+              return d(this).size;
+            }
+          }), c;
+        },
+        setStrong: function (t, e, r) {
+          var n = e + " Iterator",
+              i = g(e),
+              o = g(n);
+          f(t, e, function (t, e) {
+            p(this, {
+              type: n,
+              target: t,
+              state: i(t),
+              kind: e,
+              last: void 0
+            });
+          }, function () {
+            for (var t = o(this), e = t.kind, r = t.last; r && r.removed;) r = r.previous;
+
+            return t.target && (t.last = r = r ? r.next : t.state.first) ? "keys" == e ? {
+              value: r.key,
+              done: !1
+            } : "values" == e ? {
+              value: r.value,
+              done: !1
+            } : {
+              value: [r.key, r.value],
+              done: !1
+            } : (t.target = void 0, {
+              value: void 0,
+              done: !0
+            });
+          }, r ? "entries" : "values", !r, !0), c(e);
+        }
+      };
+    }, function (t, e, r) {
+      r(0)({
+        target: "Map",
+        stat: !0
+      }, {
+        from: r(274)
+      });
+    }, function (t, e, r) {
+
+      var n = r(5),
+          i = r(15),
+          o = r(8);
+
+      t.exports = function (t) {
+        var e,
+            r,
+            a,
+            s,
+            u = arguments.length,
+            f = u > 1 ? arguments[1] : void 0;
+        return n(this), (e = void 0 !== f) && n(f), null == t ? new this() : (r = [], e ? (a = 0, s = i(f, u > 2 ? arguments[2] : void 0, 2), o(t, function (t) {
+          r.push(s(t, a++));
+        })) : o(t, r.push, r), new this(r));
+      };
+    }, function (t, e, r) {
+      r(0)({
+        target: "Map",
+        stat: !0
+      }, {
+        of: r(276)
+      });
+    }, function (t, e, r) {
+
+      t.exports = function () {
+        for (var t = arguments.length, e = new Array(t); t--;) e[t] = arguments[t];
+
+        return new this(e);
+      };
+    }, function (t, e, r) {
+
+      var n = r(0),
+          i = r(4),
+          o = r(278);
+      n({
+        target: "Map",
+        proto: !0,
+        real: !0,
+        forced: i
+      }, {
+        deleteAll: function () {
+          return o.apply(this, arguments);
+        }
+      });
+    }, function (t, e, r) {
+
+      var n = r(2),
+          i = r(5);
+
+      t.exports = function () {
+        for (var t, e = n(this), r = i(e.delete), o = !0, a = 0, s = arguments.length; a < s; a++) t = r.call(e, arguments[a]), o = o && t;
+
+        return !!o;
+      };
+    }, function (t, e, r) {
+
+      var n = r(0),
+          i = r(4),
+          o = r(2),
+          a = r(15),
+          s = r(25),
+          u = r(8);
+      n({
+        target: "Map",
+        proto: !0,
+        real: !0,
+        forced: i
+      }, {
+        every: function (t) {
+          var e = o(this),
+              r = s(e),
+              n = a(t, arguments.length > 1 ? arguments[1] : void 0, 3);
+          return !u(r, function (t, r) {
+            if (!n(r, t, e)) return u.stop();
+          }, void 0, !0, !0).stopped;
+        }
+      });
+    }, function (t, e, r) {
+
+      var n = r(0),
+          i = r(4),
+          o = r(26),
+          a = r(2),
+          s = r(5),
+          u = r(15),
+          f = r(55),
+          c = r(25),
+          l = r(8);
+      n({
+        target: "Map",
+        proto: !0,
+        real: !0,
+        forced: i
+      }, {
+        filter: function (t) {
+          var e = a(this),
+              r = c(e),
+              n = u(t, arguments.length > 1 ? arguments[1] : void 0, 3),
+              i = new (f(e, o("Map")))(),
+              h = s(i.set);
+          return l(r, function (t, r) {
+            n(r, t, e) && h.call(i, t, r);
+          }, void 0, !0, !0), i;
+        }
+      });
+    }, function (t, e, r) {
+
+      var n = r(0),
+          i = r(4),
+          o = r(2),
+          a = r(15),
+          s = r(25),
+          u = r(8);
+      n({
+        target: "Map",
+        proto: !0,
+        real: !0,
+        forced: i
+      }, {
+        find: function (t) {
+          var e = o(this),
+              r = s(e),
+              n = a(t, arguments.length > 1 ? arguments[1] : void 0, 3);
+          return u(r, function (t, r) {
+            if (n(r, t, e)) return u.stop(r);
+          }, void 0, !0, !0).result;
+        }
+      });
+    }, function (t, e, r) {
+
+      var n = r(0),
+          i = r(4),
+          o = r(2),
+          a = r(15),
+          s = r(25),
+          u = r(8);
+      n({
+        target: "Map",
+        proto: !0,
+        real: !0,
+        forced: i
+      }, {
+        findKey: function (t) {
+          var e = o(this),
+              r = s(e),
+              n = a(t, arguments.length > 1 ? arguments[1] : void 0, 3);
+          return u(r, function (t, r) {
+            if (n(r, t, e)) return u.stop(t);
+          }, void 0, !0, !0).result;
+        }
+      });
+    }, function (t, e, r) {
+
+      var n = r(0),
+          i = r(8),
+          o = r(5);
+      n({
+        target: "Map",
+        stat: !0
+      }, {
+        groupBy: function (t, e) {
+          var r = new this();
+          o(e);
+          var n = o(r.has),
+              a = o(r.get),
+              s = o(r.set);
+          return i(t, function (t) {
+            var i = e(t);
+            n.call(r, i) ? a.call(r, i).push(t) : s.call(r, i, [t]);
+          }), r;
+        }
+      });
+    }, function (t, e, r) {
+
+      var n = r(0),
+          i = r(4),
+          o = r(2),
+          a = r(25),
+          s = r(285),
+          u = r(8);
+      n({
+        target: "Map",
+        proto: !0,
+        real: !0,
+        forced: i
+      }, {
+        includes: function (t) {
+          return u(a(o(this)), function (e, r) {
+            if (s(r, t)) return u.stop();
+          }, void 0, !0, !0).stopped;
+        }
+      });
+    }, function (t, e) {
+      t.exports = function (t, e) {
+        return t === e || t != t && e != e;
+      };
+    }, function (t, e, r) {
+
+      var n = r(0),
+          i = r(8),
+          o = r(5);
+      n({
+        target: "Map",
+        stat: !0
+      }, {
+        keyBy: function (t, e) {
+          var r = new this();
+          o(e);
+          var n = o(r.set);
+          return i(t, function (t) {
+            n.call(r, e(t), t);
+          }), r;
+        }
+      });
+    }, function (t, e, r) {
+
+      var n = r(0),
+          i = r(4),
+          o = r(2),
+          a = r(25),
+          s = r(8);
+      n({
+        target: "Map",
+        proto: !0,
+        real: !0,
+        forced: i
+      }, {
+        keyOf: function (t) {
+          return s(a(o(this)), function (e, r) {
+            if (r === t) return s.stop(e);
+          }, void 0, !0, !0).result;
+        }
+      });
+    }, function (t, e, r) {
+
+      var n = r(0),
+          i = r(4),
+          o = r(26),
+          a = r(2),
+          s = r(5),
+          u = r(15),
+          f = r(55),
+          c = r(25),
+          l = r(8);
+      n({
+        target: "Map",
+        proto: !0,
+        real: !0,
+        forced: i
+      }, {
+        mapKeys: function (t) {
+          var e = a(this),
+              r = c(e),
+              n = u(t, arguments.length > 1 ? arguments[1] : void 0, 3),
+              i = new (f(e, o("Map")))(),
+              h = s(i.set);
+          return l(r, function (t, r) {
+            h.call(i, n(r, t, e), r);
+          }, void 0, !0, !0), i;
+        }
+      });
+    }, function (t, e, r) {
+
+      var n = r(0),
+          i = r(4),
+          o = r(26),
+          a = r(2),
+          s = r(5),
+          u = r(15),
+          f = r(55),
+          c = r(25),
+          l = r(8);
+      n({
+        target: "Map",
+        proto: !0,
+        real: !0,
+        forced: i
+      }, {
+        mapValues: function (t) {
+          var e = a(this),
+              r = c(e),
+              n = u(t, arguments.length > 1 ? arguments[1] : void 0, 3),
+              i = new (f(e, o("Map")))(),
+              h = s(i.set);
+          return l(r, function (t, r) {
+            h.call(i, t, n(r, t, e));
+          }, void 0, !0, !0), i;
+        }
+      });
+    }, function (t, e, r) {
+
+      var n = r(0),
+          i = r(4),
+          o = r(2),
+          a = r(5),
+          s = r(8);
+      n({
+        target: "Map",
+        proto: !0,
+        real: !0,
+        forced: i
+      }, {
+        merge: function (t) {
+          for (var e = o(this), r = a(e.set), n = 0; n < arguments.length;) s(arguments[n++], r, e, !0);
+
+          return e;
+        }
+      });
+    }, function (t, e, r) {
+
+      var n = r(0),
+          i = r(4),
+          o = r(2),
+          a = r(5),
+          s = r(25),
+          u = r(8);
+      n({
+        target: "Map",
+        proto: !0,
+        real: !0,
+        forced: i
+      }, {
+        reduce: function (t) {
+          var e,
+              r,
+              n = o(this),
+              i = s(n);
+          if (a(t), arguments.length > 1) e = arguments[1];else {
+            if ((r = i.next()).done) throw TypeError("Reduce of empty map with no initial value");
+            e = r.value[1];
+          }
+          return u(i, function (r, i) {
+            e = t(e, i, r, n);
+          }, void 0, !0, !0), e;
+        }
+      });
+    }, function (t, e, r) {
+
+      var n = r(0),
+          i = r(4),
+          o = r(2),
+          a = r(15),
+          s = r(25),
+          u = r(8);
+      n({
+        target: "Map",
+        proto: !0,
+        real: !0,
+        forced: i
+      }, {
+        some: function (t) {
+          var e = o(this),
+              r = s(e),
+              n = a(t, arguments.length > 1 ? arguments[1] : void 0, 3);
+          return u(r, function (t, r) {
+            if (n(r, t, e)) return u.stop();
+          }, void 0, !0, !0).stopped;
+        }
+      });
+    }, function (t, e, r) {
+
+      var n = r(0),
+          i = r(4),
+          o = r(2),
+          a = r(5);
+      n({
+        target: "Map",
+        proto: !0,
+        real: !0,
+        forced: i
+      }, {
+        update: function (t, e) {
+          var r = o(this),
+              n = arguments.length;
+          a(e);
+          var i = r.has(t);
+          if (!i && n < 3) throw TypeError("Updating absent value");
+          var s = i ? r.get(t) : a(n > 2 ? arguments[2] : void 0)(t, r);
+          return r.set(t, e(s, t, r)), r;
+        }
+      });
+    }, function (t, e, r) {
+
+      var n = r(0),
+          i = r(4),
+          o = r(2),
+          a = r(5);
+      n({
+        target: "Map",
+        proto: !0,
+        real: !0,
+        forced: i
+      }, {
+        updateOrInsert: function (t, e, r) {
+          var n = o(this);
+          a(e), a(r);
+          var i = n.has(t) ? e(n.get(t)) : r();
+          return n.set(t, i), i;
+        }
+      });
+    }, function (t, e, r) {
+      var n = r(296);
+
+      t.exports = function (t) {
+        var e;
+        return -1 !== n(e = Function.toString.call(t)).call(e, "[native code]");
+      };
+    }, function (t, e, r) {
+      t.exports = r(297);
+    }, function (t, e, r) {
+      t.exports = r(143);
+    }, function (t, e, r) {
+      r(299);
+      var n = r(18);
+      t.exports = n("Array").indexOf;
+    }, function (t, e, r) {
+
+      var n = r(0),
+          i = r(82).indexOf,
+          o = r(54),
+          a = [].indexOf,
+          s = !!a && 1 / [1].indexOf(1, -0) < 0,
+          u = o("indexOf");
+      n({
+        target: "Array",
+        proto: !0,
+        forced: s || u
+      }, {
+        indexOf: function (t) {
+          return s ? a.apply(this, arguments) || 0 : i(this, t, arguments.length > 1 ? arguments[1] : void 0);
+        }
+      });
+    }, function (t, e, r) {
+      var n = r(301),
+          i = r(305),
+          o = r(96);
+
+      function a(e, r, s) {
+        return !function () {
+          if ("undefined" == typeof Reflect || !i) return !1;
+          if (i.sham) return !1;
+          if ("function" == typeof Proxy) return !0;
+
+          try {
+            return Date.prototype.toString.call(i(Date, [], function () {})), !0;
+          } catch (t) {
+            return !1;
+          }
+        }() ? t.exports = a = function (t, e, r) {
+          var i = [null];
+          i.push.apply(i, e);
+          var a = new (n(Function).apply(t, i))();
+          return r && o(a, r.prototype), a;
+        } : t.exports = a = i, a.apply(null, arguments);
+      }
+
+      t.exports = a;
+    }, function (t, e, r) {
+      t.exports = r(302);
+    }, function (t, e, r) {
+      t.exports = r(144);
+    }, function (t, e, r) {
+      r(304);
+      var n = r(18);
+      t.exports = n("Function").bind;
+    }, function (t, e, r) {
+      r(0)({
+        target: "Function",
+        proto: !0
+      }, {
+        bind: r(145)
+      });
+    }, function (t, e, r) {
+      t.exports = r(306);
+    }, function (t, e, r) {
+      t.exports = r(307);
+    }, function (t, e, r) {
+      r(308);
+      var n = r(3);
+      t.exports = n.Reflect.construct;
+    }, function (t, e, r) {
+      var n = r(0),
+          i = r(26),
+          o = r(5),
+          a = r(2),
+          s = r(14),
+          u = r(44),
+          f = r(145),
+          c = r(12),
+          l = i("Reflect", "construct"),
+          h = c(function () {
+        function t() {}
+
+        return !(l(function () {}, [], t) instanceof t);
+      }),
+          d = !c(function () {
+        l(function () {});
+      }),
+          p = h || d;
+      n({
+        target: "Reflect",
+        stat: !0,
+        forced: p,
+        sham: p
+      }, {
+        construct: function (t, e) {
+          o(t), a(e);
+          var r = arguments.length < 3 ? t : o(arguments[2]);
+          if (d && !h) return l(t, e, r);
+
+          if (t == r) {
+            switch (e.length) {
+              case 0:
+                return new t();
+
+              case 1:
+                return new t(e[0]);
+
+              case 2:
+                return new t(e[0], e[1]);
+
+              case 3:
+                return new t(e[0], e[1], e[2]);
+
+              case 4:
+                return new t(e[0], e[1], e[2], e[3]);
+            }
+
+            var n = [null];
+            return n.push.apply(n, e), new (f.apply(t, n))();
+          }
+
+          var i = r.prototype,
+              c = u(s(i) ? i : Object.prototype),
+              p = Function.apply.call(t, c, e);
+          return s(p) ? p : c;
+        }
+      });
+    }, function (t, e, r) {
+
+      (function (e) {
+        var n = r(1),
+            i = n(r(97)),
+            o = n(r(7)),
+            a = n(r(10)),
+            s = r(9).CramMalformedError,
+            u = r(73),
+            f = r(315),
+            c = r(316),
+            l = r(317),
+            h = 4;
+
+        var d = function () {
+          function t(e) {
+            var r = arguments.length > 1 && void 0 !== arguments[1] ? arguments[1] : 0;
+            (0, o.default)(this, t), this._buffer = e, this._position = r, this.length = e.length;
+          }
+
+          return (0, a.default)(t, [{
+            key: "get",
+            value: function () {
+              var t = this._buffer[this._position];
+              return this._position += 1, t;
+            }
+          }, {
+            key: "getByte",
+            value: function () {
+              return this.get();
+            }
+          }, {
+            key: "getByteAt",
+            value: function (t) {
+              return this._buffer[t];
+            }
+          }, {
+            key: "position",
+            value: function () {
+              return this._position;
+            }
+          }, {
+            key: "put",
+            value: function (t) {
+              return this._buffer[this._position] = t, this._position += 1, t;
+            }
+          }, {
+            key: "putAt",
+            value: function (t, e) {
+              return this._buffer[t] = e, e;
+            }
+          }, {
+            key: "setPosition",
+            value: function (t) {
+              return this._position = t, t;
+            }
+          }, {
+            key: "getInt",
+            value: function () {
+              var t = this._buffer.readInt32LE(this._position);
+
+              return this._position += 4, t;
+            }
+          }, {
+            key: "remaining",
+            value: function () {
+              return this._buffer.length - this._position;
+            }
+          }]), t;
+        }();
+
+        t.exports = {
+          uncompress: function (t, r) {
+            var n = arguments.length > 2 && void 0 !== arguments[2] ? arguments[2] : 0;
+            if (0 === t.length) return (0, i.default)(r).call(r, 0), r;
+            var o = new d(t, n),
+                a = o.get();
+            if (0 !== a && 1 !== a) throw new s("Invalid rANS order ".concat(a));
+            if (o.getInt() !== o.remaining() - h) throw new s("Incorrect input length.");
+            var p = o.getInt(),
+                g = new d(r || e.allocUnsafe(p));
+            if (g.length < p) throw new s("Output buffer too small to fit ".concat(p, " bytes."));
+
+            switch (a) {
+              case 0:
+                return function (t, e) {
+                  for (var r = new u.AriDecoder(), n = new Array(256), i = 0; i < n.length; i += 1) n[i] = new u.Symbol();
+
+                  return f.readStatsO0(t, r, n), c.uncompress(t, r, n, e), e;
+                }(o, g);
+
+              case 1:
+                return function (t, e) {
+                  for (var r = new Array(256), n = 0; n < r.length; n += 1) r[n] = new u.AriDecoder();
+
+                  for (var i = new Array(256), o = 0; o < i.length; o += 1) {
+                    i[o] = new Array(256);
+
+                    for (var a = 0; a < i[o].length; a += 1) i[o][a] = new u.Symbol();
+                  }
+
+                  return f.readStatsO1(t, r, i), l.uncompress(t, e, r, i), e;
+                }(o, g);
+
+              default:
+                throw new s("Invalid rANS order: ".concat(a));
+            }
+          }
+        };
+      }).call(this, r(19).Buffer);
+    }, function (t, e, r) {
+      t.exports = r(311);
+    }, function (t, e, r) {
+      var n = r(312),
+          i = Array.prototype;
+
+      t.exports = function (t) {
+        var e = t.fill;
+        return t === i || t instanceof Array && e === i.fill ? n : e;
+      };
+    }, function (t, e, r) {
+      r(313);
+      var n = r(18);
+      t.exports = n("Array").fill;
+    }, function (t, e, r) {
+      var n = r(0),
+          i = r(314),
+          o = r(78);
+      n({
+        target: "Array",
+        proto: !0
+      }, {
+        fill: i
+      }), o("fill");
+    }, function (t, e, r) {
+
+      var n = r(22),
+          i = r(84),
+          o = r(29);
+
+      t.exports = function (t) {
+        for (var e = n(this), r = o(e.length), a = arguments.length, s = i(a > 1 ? arguments[1] : void 0, r), u = a > 2 ? arguments[2] : void 0, f = void 0 === u ? r : i(u, r); f > s;) e[s++] = t;
+
+        return e;
+      };
+    }, function (t, e, r) {
+
+      var n = r(1)(r(97)),
+          i = r(9).CramMalformedError,
+          o = r(74),
+          a = r(73);
+
+      function s(t) {
+        if (!t) throw new i("assertion failed");
+      }
+
+      t.exports = {
+        readStatsO0: function (t, e, r) {
+          var i = 0,
+              u = 0,
+              f = 255 & t.get();
+
+          do {
+            var c;
+            null == e.fc[f] && (e.fc[f] = new a.FC()), e.fc[f].F = 255 & t.get(), e.fc[f].F >= 128 && (e.fc[f].F &= -129, e.fc[f].F = (127 & e.fc[f].F) << 8 | 255 & t.get()), e.fc[f].C = u, a.symbolInit(r[f], e.fc[f].C, e.fc[f].F), e.R || (e.R = new Array(o.TOTFREQ)), (0, n.default)(c = e.R).call(c, f, u, u + e.fc[f].F), u += e.fc[f].F, 0 === i && f + 1 === (255 & t.getByteAt(t.position())) ? (f = 255 & t.get(), i = 255 & t.get()) : 0 !== i ? (i -= 1, f += 1) : f = 255 & t.get();
+          } while (0 !== f);
+
+          s(u < o.TOTFREQ);
+        },
+        readStatsO1: function (t, e, r) {
+          var i = 0,
+              u = 255 & t.get();
+
+          do {
+            var f = 0,
+                c = 0,
+                l = 255 & t.get();
+            null == e[u] && (e[u] = new a.AriDecoder());
+
+            do {
+              var h;
+              null == e[u].fc[l] && (e[u].fc[l] = new a.FC()), e[u].fc[l].F = 255 & t.get(), e[u].fc[l].F >= 128 && (e[u].fc[l].F &= -129, e[u].fc[l].F = (127 & e[u].fc[l].F) << 8 | 255 & t.get()), e[u].fc[l].C = c, 0 === e[u].fc[l].F && (e[u].fc[l].F = o.TOTFREQ), null == r[u][l] && (r[u][l] = new a.RansDecSymbol()), a.symbolInit(r[u][l], e[u].fc[l].C, e[u].fc[l].F), null == e[u].R && (e[u].R = new Array(o.TOTFREQ)), (0, n.default)(h = e[u].R).call(h, l, c, c + e[u].fc[l].F), s((c += e[u].fc[l].F) <= o.TOTFREQ), 0 === f && l + 1 === (255 & t.getByteAt(t.position())) ? (l = 255 & t.get(), f = 255 & t.get()) : 0 !== f ? (f -= 1, l += 1) : l = 255 & t.get();
+            } while (0 !== l);
+
+            0 === i && u + 1 === (255 & t.getByteAt(t.position())) ? (u = 255 & t.get(), i = 255 & t.get()) : 0 !== i ? (i -= 1, u += 1) : u = 255 & t.get();
+          } while (0 !== u);
+        }
+      };
+    }, function (t, e, r) {
+
+      var n = r(9).CramMalformedError,
+          i = r(74),
+          o = r(73);
+      t.exports = {
+        uncompress: function (t, e, r, a) {
+          for (var s, u = t.getInt(), f = t.getInt(), c = t.getInt(), l = t.getInt(), h = a.remaining(), d = -4 & h, p = 0; p < d; p += 4) {
+            var g = e.R[o.get(u, i.TF_SHIFT)],
+                v = e.R[o.get(f, i.TF_SHIFT)],
+                y = e.R[o.get(c, i.TF_SHIFT)],
+                m = e.R[o.get(l, i.TF_SHIFT)];
+            a.putAt(p, g), a.putAt(p + 1, v), a.putAt(p + 2, y), a.putAt(p + 3, m), u = o.advanceSymbolStep(u, r[255 & g], i.TF_SHIFT), f = o.advanceSymbolStep(f, r[255 & v], i.TF_SHIFT), c = o.advanceSymbolStep(c, r[255 & y], i.TF_SHIFT), l = o.advanceSymbolStep(l, r[255 & m], i.TF_SHIFT), u = o.renormalize(u, t), f = o.renormalize(f, t), c = o.renormalize(c, t), l = o.renormalize(l, t);
+          }
+
+          switch (a.setPosition(d), 3 & h) {
+            case 0:
+              break;
+
+            case 1:
+              s = e.R[o.get(u, i.TF_SHIFT)], o.advanceSymbol(u, t, r[255 & s], i.TF_SHIFT), a.put(s);
+              break;
+
+            case 2:
+              s = e.R[o.get(u, i.TF_SHIFT)], o.advanceSymbol(u, t, r[255 & s], i.TF_SHIFT), a.put(s), s = e.R[o.get(f, i.TF_SHIFT)], o.advanceSymbol(f, t, r[255 & s], i.TF_SHIFT), a.put(s);
+              break;
+
+            case 3:
+              s = e.R[o.get(u, i.TF_SHIFT)], o.advanceSymbol(u, t, r[255 & s], i.TF_SHIFT), a.put(s), s = e.R[o.get(f, i.TF_SHIFT)], o.advanceSymbol(f, t, r[255 & s], i.TF_SHIFT), a.put(s), s = e.R[o.get(c, i.TF_SHIFT)], o.advanceSymbol(c, t, r[255 & s], i.TF_SHIFT), a.put(s);
+              break;
+
+            default:
+              throw new n("invalid output size encountered during rANS decoding");
+          }
+
+          a.setPosition(0);
+        }
+      };
+    }, function (t, e, r) {
+
+      var n = r(74),
+          i = r(73);
+      t.exports = {
+        uncompress: function (t, e, r, o) {
+          for (var a = e.remaining(), s = t.getInt(), u = t.getInt(), f = t.getInt(), c = t.getInt(), l = a >> 2, h = 0, d = l, p = 2 * l, g = 3 * l, v = 0, y = 0, m = 0, b = 0; h < l; h += 1, d += 1, p += 1, g += 1) {
+            var _ = 255 & r[v].R[i.get(s, n.TF_SHIFT)],
+                w = 255 & r[y].R[i.get(u, n.TF_SHIFT)],
+                x = 255 & r[m].R[i.get(f, n.TF_SHIFT)],
+                E = 255 & r[b].R[i.get(c, n.TF_SHIFT)];
+
+            e.putAt(h, _), e.putAt(d, w), e.putAt(p, x), e.putAt(g, E), s = i.advanceSymbolStep(s, o[v][_], n.TF_SHIFT), u = i.advanceSymbolStep(u, o[y][w], n.TF_SHIFT), f = i.advanceSymbolStep(f, o[m][x], n.TF_SHIFT), c = i.advanceSymbolStep(c, o[b][E], n.TF_SHIFT), s = i.renormalize(s, t), u = i.renormalize(u, t), f = i.renormalize(f, t), c = i.renormalize(c, t), v = _, y = w, m = x, b = E;
+          }
+
+          for (; g < a; g += 1) {
+            var S = 255 & r[b].R[i.get(c, n.TF_SHIFT)];
+            e.putAt(g, S), c = i.advanceSymbol(c, t, o[b][S], n.TF_SHIFT), b = S;
+          }
+        }
+      };
+    }, function (t, e, r) {
+
+      var n = r(1),
+          i = n(r(98)),
+          o = n(r(16)),
+          a = n(r(75)),
+          s = r(326).Parser,
+          u = new s().itf8(),
+          f = {
+        parser: new s().string("magic", {
+          length: 4
+        }).uint8("majorVersion").uint8("minorVersion").string("fileId", {
+          length: 20,
+          stripNull: !0
+        }),
+        maxLength: 26
+      },
+          c = {
+        parser: new s().uint8("compressionMethod", {
+          formatter: function (t) {
+            var e = ["raw", "gzip", "bzip2", "lzma", "rans"][t];
+            if (!e) throw new Error("compression method number ".concat(t, " not implemented"));
+            return e;
+          }
+        }).uint8("contentType", {
+          formatter: function (t) {
+            var e = ["FILE_HEADER", "COMPRESSION_HEADER", "MAPPED_SLICE_HEADER", "UNMAPPED_SLICE_HEADER", "EXTERNAL_DATA", "CORE_DATA"][t];
+            if (!e) throw new Error("invalid block content type id ".concat(t));
+            return e;
+          }
+        }).itf8("contentId").itf8("compressedSize").itf8("uncompressedSize"),
+        maxLength: 17
+      },
+          l = {
+        parser: new s().uint32("crc32"),
+        maxLength: 4
+      },
+          h = new s().itf8("size").buffer("ents", {
+        length: "size",
+        formatter: function (t) {
+          function e(e, r) {
+            for (var n = t.toString("utf8", e, r), i = [], o = 0; o < n.length; o += 3) i.push(n.substr(o, 3));
+
+            return i;
+          }
+
+          var r,
+              n = [],
+              i = 0;
+
+          for (r = 0; r < t.length; r += 1) t[r] || (n.push(e(i, r)), i = r + 1);
+
+          return r > i && n.push(e(i, r)), n;
+        }
+      }),
+          d = new s().uint8(null, {
+        formatter: function (t) {
+          return !!t;
+        }
+      }),
+          p = new s().itf8("mapSize").itf8("mapCount").array("ents", {
+        length: "mapCount",
+        type: new s().string("key", {
+          length: 2,
+          stripNull: !1
+        }).choice("value", {
+          tag: "key",
+          choices: {
+            MI: d,
+            UI: d,
+            PI: d,
+            RN: d,
+            AP: d,
+            RR: d,
+            SM: new s().array(null, {
+              type: "uint8",
+              length: 5
+            }),
+            TD: new s().nest(null, {
+              type: h,
+              formatter: function (t) {
+                return t.ents;
+              }
+            })
+          }
+        })
+      });
+
+      function g(t) {
+        for (var e = {}, r = 0; r < t.ents.length; r += 1) {
+          var n = t.ents[r],
+              i = n.key,
+              o = n.value;
+          e[i] && console.warn("duplicate key ".concat(i, " in map")), e[i] = o;
+        }
+
+        return e;
+      }
+
+      var v = {
+        cramFileDefinition: f,
+        cramBlockHeader: c,
+        cramBlockCrc32: l
+      },
+          y = {
+        cramUnmappedSliceHeader: function (t) {
+          var e = 0,
+              r = new s().itf8("numRecords");
+          e += 5, t >= 3 ? (r = r.ltf8("recordCounter"), e += 9) : 2 === t && (r = r.itf8("recordCounter"), e += 5), r = r.itf8("numBlocks").itf8("numContentIds").array("contentIds", {
+            type: u,
+            length: "numContentIds"
+          }), e += 10, t >= 2 && (r = r.array("md5", {
+            type: "uint8",
+            length: 16
+          }), e += 16);
+          return {
+            parser: r,
+            maxLength: function (t) {
+              return e + 5 * t;
+            }
+          };
+        },
+        cramMappedSliceHeader: function (t) {
+          var e = new s().itf8("refSeqId").itf8("refSeqStart").itf8("refSeqSpan").itf8("numRecords"),
+              r = 20;
+          t >= 3 ? (e = e.ltf8("recordCounter"), r += 9) : 2 === t && (e = e.itf8("recordCounter"), r += 5), e = e.itf8("numBlocks").itf8("numContentIds").array("contentIds", {
+            type: u,
+            length: "numContentIds"
+          }).itf8("refBaseBlockId"), r += 15, t >= 2 && (e = e.array("md5", {
+            type: "uint8",
+            length: 16
+          }), r += 16);
+          return {
+            parser: e,
+            maxLength: function (t) {
+              return r + 5 * t;
+            }
+          };
+        },
+        cramEncoding: function (t) {
+          return {
+            parser: new s().namely("cramEncoding").itf8("codecId").itf8("parametersBytes").choice("parameters", {
+              tag: "codecId",
+              choices: {
+                0: new s(),
+                1: new s().itf8("blockContentId"),
+                2: new s().itf8("offset").itf8("M"),
+                3: s.start().itf8("numCodes").array("symbols", {
+                  length: "numCodes",
+                  type: u
+                }).itf8("numLengths").array("bitLengths", {
+                  length: "numLengths",
+                  type: u
+                }),
+                4: s.start().nest("lengthsEncoding", {
+                  type: "cramEncoding"
+                }).nest("valuesEncoding", {
+                  type: "cramEncoding"
+                }),
+                5: new s().uint8("stopByte")[t > 1 ? "itf8" : "int"]("blockContentId"),
+                6: new s().itf8("offset").itf8("length"),
+                7: new s().itf8("offset").itf8("K"),
+                8: new s().itf8("offset").itf8("log2m"),
+                9: new s().itf8("offset")
+              }
+            })
+          };
+        },
+        cramDataSeriesEncodingMap: function (t) {
+          return new s().itf8("mapSize").itf8("mapCount").array("ents", {
+            length: "mapCount",
+            type: new s().string("key", {
+              length: 2,
+              stripNull: !1
+            }).nest("value", {
+              type: this.cramEncoding(t).parser
+            })
+          });
+        },
+        cramTagEncodingMap: function (t) {
+          return new s().itf8("mapSize").itf8("mapCount").array("ents", {
+            length: "mapCount",
+            type: new s().itf8("key", {
+              formatter: function (t) {
+                return String.fromCharCode(t >> 16 & 255) + String.fromCharCode(t >> 8 & 255) + String.fromCharCode(255 & t);
+              }
+            }).nest("value", {
+              type: this.cramEncoding(t).parser
+            })
+          });
+        },
+        cramCompressionHeader: function (t) {
+          var e = new s();
+          return {
+            parser: e = e.nest("preservation", {
+              type: p,
+              formatter: g
+            }).nest("dataSeriesEncoding", {
+              type: this.cramDataSeriesEncodingMap(t),
+              formatter: g
+            }).nest("tagEncoding", {
+              type: this.cramTagEncodingMap(t),
+              formatter: g
+            })
+          };
+        },
+        cramContainerHeader1: function (t) {
+          var e = new s().int32("length").itf8("refSeqId").itf8("refSeqStart").itf8("alignmentSpan").itf8("numRecords"),
+              r = 24;
+          return t >= 3 ? (e = e.ltf8("recordCounter"), r += 9) : 2 === t && (e = e.itf8("recordCounter"), r += 5), t > 1 && (e = e.ltf8("numBases"), r += 9), {
+            parser: e = e.itf8("numBlocks").itf8("numLandmarks"),
+            maxLength: r += 10
+          };
+        },
+        cramContainerHeader2: function (t) {
+          var e = new s().itf8("numLandmarks").array("landmarks", {
+            type: new s().itf8(),
+            length: "numLandmarks"
+          }),
+              r = 0;
+          return t >= 3 && (e = e.uint32("crc32"), r = 4), {
+            parser: e,
+            maxLength: function (t) {
+              return 5 + 5 * t + r;
+            }
+          };
+        }
+      };
+      t.exports = {
+        cramFileDefinition: f,
+        getSectionParsers: function (t) {
+          var e,
+              r = (0, a.default)({}, v);
+          return (0, o.default)(e = (0, i.default)(y)).call(e, function (e) {
+            r[e] = y[e](t);
+          }), r;
+        }
+      };
+    }, function (t, e, r) {
+      t.exports = r(320);
+    }, function (t, e, r) {
+      r(321);
+      var n = r(3);
+      t.exports = n.Object.keys;
+    }, function (t, e, r) {
+      var n = r(0),
+          i = r(22),
+          o = r(51);
+      n({
+        target: "Object",
+        stat: !0,
+        forced: r(12)(function () {
+          o(1);
+        })
+      }, {
+        keys: function (t) {
+          return o(i(t));
+        }
+      });
+    }, function (t, e, r) {
+      t.exports = r(323);
+    }, function (t, e, r) {
+      r(324);
+      var n = r(3);
+      t.exports = n.Object.assign;
+    }, function (t, e, r) {
+      var n = r(0),
+          i = r(325);
+      n({
+        target: "Object",
+        stat: !0,
+        forced: Object.assign !== i
+      }, {
+        assign: i
+      });
+    }, function (t, e, r) {
+
+      var n = r(17),
+          i = r(12),
+          o = r(51),
+          a = r(138),
+          s = r(65),
+          u = r(22),
+          f = r(60),
+          c = Object.assign;
+      t.exports = !c || i(function () {
+        var t = {},
+            e = {},
+            r = Symbol();
+        return t[r] = 7, "abcdefghijklmnopqrst".split("").forEach(function (t) {
+          e[t] = t;
+        }), 7 != c({}, t)[r] || "abcdefghijklmnopqrst" != o(c({}, e)).join("");
+      }) ? function (t, e) {
+        for (var r = u(t), i = arguments.length, c = 1, l = a.f, h = s.f; i > c;) for (var d, p = f(arguments[c++]), g = l ? o(p).concat(l(p)) : o(p), v = g.length, y = 0; v > y;) d = g[y++], n && !h.call(p, d) || (r[d] = p[d]);
+
+        return r;
+      } : c;
+    }, function (t, e, r) {
+
+      (function (t) {
+        function n(t) {
+          return (n = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (t) {
+            return typeof t;
+          } : function (t) {
+            return t && "function" == typeof Symbol && t.constructor === Symbol && t !== Symbol.prototype ? "symbol" : typeof t;
+          })(t);
+        }
+
+        var i = r(327),
+            o = r(328).Context,
+            a = r(146);
+        "undefined" != typeof window && (window.Buffer = t), "undefined" != typeof self && (self.Buffer = t);
+        var s = {
+          UInt8: 1,
+          UInt16LE: 2,
+          UInt16BE: 2,
+          UInt32LE: 4,
+          UInt32BE: 4,
+          Int8: 1,
+          Int16LE: 2,
+          Int16BE: 2,
+          Int32LE: 4,
+          Int32BE: 4,
+          FloatLE: 4,
+          FloatBE: 4,
+          DoubleLE: 8,
+          DoubleBE: 8,
+          UInt64: 8,
+          Int64: 8
+        },
+            u = {},
+            f = [];
+        !function () {
+          var t;
+
+          for (t = 1; t <= 32; t++) f.push(t);
+        }();
+        var c = {};
+        Object.keys(s).concat(Object.keys({
+          String: null,
+          Buffer: null,
+          Array: null,
+          Skip: null,
+          Choice: null,
+          Nest: null,
+          Bit: null,
+          Itf8: null,
+          Ltf8: null
+        })).forEach(function (t) {
+          c[t.toLowerCase()] = t;
+        });
+
+        var l = function () {
+          this.varName = "", this.type = "", this.options = {}, this.next = null, this.head = null, this.compiled = null, this.endian = "le", this.constructorFn = null, this.alias = null;
+        };
+
+        l.start = function () {
+          return new l();
+        }, Object.keys(s).forEach(function (t) {
+          l.prototype[t.toLowerCase()] = function (e, r) {
+            return this.setNextParser(t.toLowerCase(), e, r);
+          };
+
+          var e = t.replace(/BE|LE/, "").toLowerCase();
+          e in l.prototype || (l.prototype[e] = function (t, r) {
+            return this[e + this.endian](t, r);
+          });
+        }), f.forEach(function (t) {
+          l.prototype["bit".concat(t.toString())] = function (e, r) {
+            return r || (r = {}), r.length = t, this.setNextParser("bit", e, r);
+          };
+        }), l.prototype.namely = function (t) {
+          return u[t] = this, this.alias = t, this;
+        }, l.prototype.skip = function (t, e) {
+          if (e && e.assert) throw new Error("assert option on skip is not allowed.");
+          return this.setNextParser("skip", "", {
+            length: t
+          });
+        }, l.prototype.string = function (t, e) {
+          if (!e.zeroTerminated && !e.length && !e.greedy) throw new Error("Neither length, zeroTerminated, nor greedy is defined for string.");
+          if ((e.zeroTerminated || e.length) && e.greedy) throw new Error("greedy is mutually exclusive with length and zeroTerminated for string.");
+          if (e.stripNull && !e.length && !e.greedy) throw new Error("Length or greedy must be defined if stripNull is defined.");
+          return e.encoding = e.encoding || "utf8", this.setNextParser("string", t, e);
+        }, l.prototype.buffer = function (t, e) {
+          if (!e.length && !e.readUntil) throw new Error("Length nor readUntil is defined in buffer parser");
+          return this.setNextParser("buffer", t, e);
+        }, l.prototype.array = function (t, e) {
+          if (!e.readUntil && !e.length && !e.lengthInBytes) throw new Error("Length option of array is not defined.");
+          if (!e.type) throw new Error("Type option of array is not defined.");
+          if ("string" == typeof e.type && !u[e.type] && Object.keys(s).indexOf(c[e.type]) < 0) throw new Error('Specified primitive type "'.concat(e.type, '" is not supported.'));
+          return this.setNextParser("array", t, e);
+        }, l.prototype.choice = function (t, e) {
+          if (1 === arguments.length && "object" === n(t) && (e = t, t = null), !e.tag) throw new Error("Tag option of array is not defined.");
+          if (!e.choices) throw new Error("Choices option of array is not defined.");
+          return Object.keys(e.choices).forEach(function (r) {
+            if (!e.choices[r]) throw new Error("Choice Case ".concat(r, " of ").concat(t, " is not valid."));
+            if ("string" == typeof e.choices[r] && !u[e.choices[r]] && Object.keys(s).indexOf(c[e.choices[r]]) < 0) throw new Error('Specified primitive type "'.concat(e.choices[r], '" is not supported.'));
+          }, this), this.setNextParser("choice", t, e);
+        }, l.prototype.nest = function (t, e) {
+          if (1 === arguments.length && "object" === n(t) && (e = t, t = null), !e.type) throw new Error("Type option of nest is not defined.");
+          if (!(e.type instanceof l || u[e.type])) throw new Error("Type option of nest must be a Parser object.");
+          if (!(e.type instanceof l || t)) throw new Error("options.type must be a object if variable name is omitted.");
+          return this.setNextParser("nest", t, e);
+        }, l.prototype.endianess = function (t) {
+          switch (t.toLowerCase()) {
+            case "little":
+              this.endian = "le";
+              break;
+
+            case "big":
+              this.endian = "be";
+              break;
+
+            default:
+              throw new Error("Invalid endianess: ".concat(t));
+          }
+
+          return this;
+        }, l.prototype.create = function (t) {
+          if (!(t instanceof Function)) throw new Error("Constructor must be a Function object.");
+          return this.constructorFn = t, this;
+        }, l.prototype.getCode = function () {
+          var t = new o();
+          return t.pushCode("if (!Buffer.isBuffer(buffer)) {"), t.generateError('"argument buffer is not a Buffer object"'), t.pushCode("}"), this.alias ? this.addAliasedCode(t) : this.addRawCode(t), this.alias ? t.pushCode("return {0}(0)", "___parser_" + this.alias) : t.pushCode("return { offset: offset, result: vars };"), t.code;
+        }, l.prototype.addRawCode = function (t) {
+          t.pushCode("var offset = 0;"), this.constructorFn ? t.pushCode("var vars = new constructorFn();") : t.pushCode("var vars = {};"), this.generate(t), this.resolveReferences(t), t.pushCode("return { offset: offset, result: vars };");
+        }, l.prototype.addAliasedCode = function (t) {
+          return t.pushCode("function {0}(offset) {", "___parser_" + this.alias), this.constructorFn ? t.pushCode("var vars = new constructorFn();") : t.pushCode("var vars = {};"), this.generate(t), t.markResolved(this.alias), this.resolveReferences(t), t.pushCode("return { offset: offset, result: vars };"), t.pushCode("}"), t;
+        }, l.prototype.resolveReferences = function (t) {
+          var e = t.getUnresolvedReferences();
+          t.markRequested(e), e.forEach(function (e) {
+            u[e].addAliasedCode(t);
+          });
+        }, l.prototype.compile = function () {
+          var t = "(function(buffer, constructorFn, Long) { ".concat(this.getCode(), " })");
+          this.compiled = i.runInThisContext(t);
+        }, l.prototype.sizeOf = function () {
+          var t = NaN;
+          if (Object.keys(s).indexOf(this.type) >= 0) t = s[this.type];else if ("String" === this.type && "number" == typeof this.options.length) t = this.options.length;else if ("Buffer" === this.type && "number" == typeof this.options.length) t = this.options.length;else if ("Array" === this.type && "number" == typeof this.options.length) {
+            var e = NaN;
+            "string" == typeof this.options.type ? e = s[c[this.options.type]] : this.options.type instanceof l && (e = this.options.type.sizeOf()), t = this.options.length * e;
+          } else "Skip" === this.type ? t = this.options.length : "Nest" === this.type ? t = this.options.type.sizeOf() : this.type || (t = 0);
+          return this.next && (t += this.next.sizeOf()), t;
+        }, l.prototype.parse = function (t) {
+          return this.compiled || this.compile(), this.compiled(t, this.constructorFn, a);
+        }, l.prototype.setNextParser = function (t, e, r) {
+          var n = new l();
+          return n.type = c[t], n.varName = e, n.options = r || n.options, n.endian = this.endian, this.head ? this.head.next = n : this.next = n, this.head = n, this;
+        }, l.prototype.generate = function (t) {
+          this.type && (this["generate".concat(this.type)](t), this.generateAssert(t));
+          var e = t.generateVariable(this.varName);
+          return this.options.formatter && this.generateFormatter(t, e, this.options.formatter), this.generateNext(t);
+        }, l.prototype.generateAssert = function (t) {
+          if (this.options.assert) {
+            var e = t.generateVariable(this.varName);
+
+            switch (n(this.options.assert)) {
+              case "function":
+                t.pushCode("if (!({0}).call(vars, {1})) {", this.options.assert, e);
+                break;
+
+              case "number":
+                t.pushCode("if ({0} !== {1}) {", this.options.assert, e);
+                break;
+
+              case "string":
+                t.pushCode('if ("{0}" !== {1}) {', this.options.assert, e);
+                break;
+
+              default:
+                throw new Error("Assert option supports only strings, numbers and assert functions.");
+            }
+
+            t.generateError('"Assert error: {0} is " + {0}', e), t.pushCode("}");
+          }
+        }, l.prototype.generateNext = function (t) {
+          return this.next && (t = this.next.generate(t)), t;
+        }, Object.keys(s).forEach(function (t) {
+          l.prototype["generate".concat(t)] = function (e) {
+            "UInt64" === t ? e.pushCode("{0} = Long.fromBytes(buffer.slice(offset,offset+8), true, this.endian === 'le').toNumber();", e.generateVariable(this.varName), t) : "Int64" === t ? e.pushCode("{0} = Long.fromBytes(buffer.slice(offset,offset+8), false, this.endian === 'le').toNumber();", e.generateVariable(this.varName), t) : e.pushCode("{0} = buffer.read{1}(offset);", e.generateVariable(this.varName), t), e.pushCode("offset += {0};", s[t]);
+          };
+        }), l.prototype.generateBit = function (t) {
+          var e = JSON.parse(JSON.stringify(this));
+
+          if (e.varName = t.generateVariable(e.varName), t.bitFields.push(e), !this.next || this.next && ["Bit", "Nest"].indexOf(this.next.type) < 0) {
+            var r = 0;
+            t.bitFields.forEach(function (t) {
+              r += t.options.length;
+            });
+            var n = t.generateTmpVariable();
+            if (r <= 8) t.pushCode("var {0} = buffer.readUInt8(offset);", n), r = 8;else if (r <= 16) t.pushCode("var {0} = buffer.readUInt16BE(offset);", n), r = 16;else if (r <= 24) {
+              var i = t.generateTmpVariable(),
+                  o = t.generateTmpVariable();
+              t.pushCode("var {0} = buffer.readUInt16BE(offset);", i), t.pushCode("var {0} = buffer.readUInt8(offset + 2);", o), t.pushCode("var {2} = ({0} << 8) | {1};", i, o, n), r = 24;
+            } else {
+              if (!(r <= 32)) throw new Error("Currently, bit field sequence longer than 4-bytes is not supported.");
+              t.pushCode("var {0} = buffer.readUInt32BE(offset);", n), r = 32;
+            }
+            t.pushCode("offset += {0};", r / 8);
+            var a = 0,
+                s = "be" === this.endian;
+            t.bitFields.forEach(function (e) {
+              t.pushCode("{0} = {1} >> {2} & {3};", e.varName, n, s ? r - a - e.options.length : a, (1 << e.options.length) - 1), a += e.options.length;
+            }), t.bitFields = [];
+          }
+        }, l.prototype.generateSkip = function (t) {
+          var e = t.generateOption(this.options.length);
+          t.pushCode("offset += {0};", e);
+        }, l.prototype.generateString = function (t) {
+          var e = t.generateVariable(this.varName),
+              r = t.generateTmpVariable();
+          this.options.length && this.options.zeroTerminated ? (t.pushCode("var {0} = offset;", r), t.pushCode("while(buffer.readUInt8(offset++) !== 0 && offset - {0}  < {1});", r, this.options.length), t.pushCode("{0} = buffer.toString('{1}', {2}, offset - {2} < {3} ? offset - 1 : offset);", e, this.options.encoding, r, this.options.length)) : this.options.length ? (t.pushCode("{0} = buffer.toString('{1}', offset, offset + {2});", e, this.options.encoding, t.generateOption(this.options.length)), t.pushCode("offset += {0};", t.generateOption(this.options.length))) : this.options.zeroTerminated ? (t.pushCode("var {0} = offset;", r), t.pushCode("while(buffer.readUInt8(offset++) !== 0);"), t.pushCode("{0} = buffer.toString('{1}', {2}, offset - 1);", e, this.options.encoding, r)) : this.options.greedy && (t.pushCode("var {0} = offset;", r), t.pushCode("while(buffer.length > offset++);"), t.pushCode("{0} = buffer.toString('{1}', {2}, offset);", e, this.options.encoding, r)), this.options.stripNull && t.pushCode("{0} = {0}.replace(/\\x00+$/g, '')", e);
+        }, l.prototype.generateBuffer = function (t) {
+          "eof" === this.options.readUntil ? t.pushCode("{0} = buffer.slice(offset);", t.generateVariable(this.varName)) : (t.pushCode("{0} = buffer.slice(offset, offset + {1});", t.generateVariable(this.varName), t.generateOption(this.options.length)), t.pushCode("offset += {0};", t.generateOption(this.options.length))), this.options.clone && t.pushCode("{0} = Buffer.from({0});", t.generateVariable(this.varName));
+        }, l.prototype.generateArray = function (t) {
+          var e = t.generateOption(this.options.length),
+              r = t.generateOption(this.options.lengthInBytes),
+              n = this.options.type,
+              i = t.generateTmpVariable(),
+              o = t.generateVariable(this.varName),
+              a = t.generateTmpVariable(),
+              f = this.options.key,
+              h = "string" == typeof f;
+          if (h ? t.pushCode("{0} = {};", o) : t.pushCode("{0} = [];", o), "function" == typeof this.options.readUntil ? t.pushCode("do {") : "eof" === this.options.readUntil ? t.pushCode("for (var {0} = 0; offset < buffer.length; {0}++) {", i) : void 0 !== r ? t.pushCode("for (var {0} = offset; offset - {0} < {1}; ) {", i, r) : t.pushCode("for (var {0} = 0; {0} < {1}; {0}++) {", i, e), "string" == typeof n) {
+            if (u[n]) {
+              var d = t.generateTmpVariable();
+              t.pushCode("var {0} = {1}(offset);", d, "___parser_" + n), t.pushCode("var {0} = {1}.result; offset = {1}.offset;", a, d), n !== this.alias && t.addReference(n);
+            } else t.pushCode("var {0} = buffer.read{1}(offset);", a, c[n]), t.pushCode("offset += {0};", s[c[n]]);
+          } else n instanceof l && (t.pushCode("var {0} = {};", a), t.pushScope(a), n.generate(t), t.popScope());
+          h ? t.pushCode("{0}[{2}.{1}] = {2};", o, f, a) : t.pushCode("{0}.push({1});", o, a), t.pushCode("}"), "function" == typeof this.options.readUntil && t.pushCode(" while (!({0}).call(this, {1}, buffer.slice(offset)));", this.options.readUntil, a);
+        }, l.prototype.generateChoiceCase = function (t, e, r) {
+          if ("string" == typeof r) {
+            if (u[r]) {
+              var n = t.generateTmpVariable();
+              t.pushCode("var {0} = {1}(offset);", n, "___parser_" + r), t.pushCode("{0} = {1}.result; offset = {1}.offset;", t.generateVariable(this.varName), n), r !== this.alias && t.addReference(r);
+            } else t.pushCode("{0} = buffer.read{1}(offset);", t.generateVariable(this.varName), c[r]), t.pushCode("offset += {0};", s[c[r]]);
+          } else r instanceof l && (t.pushPath(e), r.generate(t), t.popPath(e));
+        }, l.prototype.generateChoice = function (t) {
+          var e = t.generateOption(this.options.tag);
+          this.varName && t.pushCode("{0} = {};", t.generateVariable(this.varName)), t.pushCode("switch({0}) {", e), Object.keys(this.options.choices).forEach(function (e) {
+            var r = this.options.choices[e];
+            Number.isNaN(parseInt(e, 10)) ? t.pushCode("case '{0}':", e) : t.pushCode("case {0}:", e), this.generateChoiceCase(t, this.varName, r), t.pushCode("break;");
+          }, this), t.pushCode("default:"), this.options.defaultChoice ? this.generateChoiceCase(t, this.varName, this.options.defaultChoice) : t.generateError('"Met undefined tag value " + {0} + " at choice"', e), t.pushCode("}");
+        }, l.prototype.generateNest = function (t) {
+          var e = t.generateVariable(this.varName);
+          if (this.options.type instanceof l) this.varName && t.pushCode("{0} = {};", e), t.pushPath(this.varName), this.options.type.generate(t), t.popPath(this.varName);else if (u[this.options.type]) {
+            var r = t.generateTmpVariable();
+            t.pushCode("var {0} = {1}(offset);", r, "___parser_" + this.options.type), t.pushCode("{0} = {1}.result; offset = {1}.offset;", e, r), this.options.type !== this.alias && t.addReference(this.options.type);
+          }
+        }, l.prototype.generateFormatter = function (t, e, r) {
+          "function" == typeof r && t.pushCode("{0} = ({1}).call(this, {0});", e, r);
+        }, l.prototype.isInteger = function () {
+          return !!this.type.match(/U?Int[8|16|32][BE|LE]?|Bit\d+/);
+        }, l.prototype.itf8 = function (t, e) {
+          return this.setNextParser("itf8", t, e);
+        }, l.prototype.itf8 = function (t, e) {
+          return this.setNextParser("itf8", t, e);
+        }, l.prototype.generateItf8 = function (t) {
+          var e = t.generateVariable(this.varName),
+              r = t.generateTmpVariable();
+          t.pushCode("\n    var ".concat(r, " = buffer[offset];\n    if (").concat(r, " < 0x80) {\n      ").concat(e, " = ").concat(r, ";\n      offset += 1;\n    } else if (").concat(r, " < 0xc0) {\n      ").concat(e, " = ((").concat(r, "<<8) | buffer[offset+1]) & 0x3fff;\n      offset += 2;\n    } else if (").concat(r, " < 0xe0) {\n      ").concat(e, " = ((").concat(r, "<<16) | (buffer[offset+1]<< 8) |  buffer[offset+2]) & 0x1fffff;\n      offset += 3;\n    } else if (").concat(r, " < 0xf0) {\n      ").concat(e, " = ((").concat(r, "<<24) | (buffer[offset+1]<<16) | (buffer[offset+2]<<8) | buffer[offset+3]) & 0x0fffffff;\n      offset += 4\n    } else {\n      ").concat(e, " = ((").concat(r, " & 0x0f)<<28) | (buffer[offset+1]<<20) | (buffer[offset+2]<<12) | (buffer[offset+3]<<4) | (buffer[offset+4] & 0x0f);\n      // x=((0xff & 0x0f)<<28) | (0xff<<20) | (0xff<<12) | (0xff<<4) | (0x0f & 0x0f);\n      // TODO *val_p = uv < 0x80000000UL ? uv : -((int32_t) (0xffffffffUL - uv)) - 1;\n      offset += 5\n    }\n  "));
+        }, l.prototype.ltf8 = function (t, e) {
+          return this.setNextParser("ltf8", t, e);
+        }, l.prototype.generateLtf8 = function (t) {
+          var e = t.generateVariable(this.varName),
+              r = t.generateTmpVariable();
+          t.pushCode("\n  var ".concat(r, " = buffer[offset];\n  if (").concat(r, " < 0x80) {\n    ").concat(e, " = ").concat(r, ";\n    offset += 1;\n  } else if (").concat(r, " < 0xc0) {\n    ").concat(e, " = ((buffer[offset]<<8) | buffer[offset+1]) & 0x3fff;\n    offset += 2;\n  } else if (").concat(r, " < 0xe0) {\n    ").concat(e, " = ((buffer[offset]<<16) | (buffer[offset+1]<<8) | buffer[offset+2]) & 0x1fffff;\n    ").concat(e, " = (((").concat(r, " & 63) << 16) | buffer.readUInt16LE(offset + 1));\n    offset += 3;\n  } else if (").concat(r, " < 0xf0) {\n    ").concat(e, " = ((buffer[offset]<<24) | (buffer[offset+1]<<16) | (buffer[offset+2]<<8) | buffer[offset+3]) & 0x0fffffff;\n    offset += 4;\n  } else if (").concat(r, " < 0xf8) {\n    ").concat(e, " = (((buffer[offset] & 15) * Math.pow(2,32))) +\n      (buffer[offset+1]<<24) | (buffer[offset+2]<<16 | buffer[offset+3]<<8 | buffer[offset+4])\n    // TODO *val_p = uv < 0x80000000UL ? uv : -((int32_t) (0xffffffffUL - uv)) - 1;\n    offset += 5;\n  } else if (").concat(r, " < 0xfc) {\n    ").concat(e, " = ((((buffer[offset] & 7) << 8) | buffer[offset+1] )) * Math.pow(2,32) +\n      (buffer[offset+2]<<24) | (buffer[offset+3]<<16 | buffer[offset+4]<<8 | buffer[offset+5])\n    offset += 6;\n  } else if (").concat(r, " < 0xfe) {\n    ").concat(e, " = ((((buffer[offset] & 3) << 16) | buffer[offset+1]<<8 | buffer[offset+2])) * Math.pow(2,32) +\n      (buffer[offset+3]<<24) | (buffer[offset+4]<<16 | buffer[offset+5]<<8 | buffer[offset+6])\n    offset += 7;\n  } else if (").concat(r, " < 0xff) {\n    ").concat(e, " = Long.fromBytesBE(buffer.slice(offset+1,offset+8));\n    if (").concat(e, ".greaterThan(Number.MAX_SAFE_INTEGER) || ").concat(e, ".lessThan(Number.MIN_SAFE_INTEGER))\n      throw new Error('integer overflow')\n    ").concat(e, " = ").concat(e, ".toNumber()\n    offset += 8;\n  } else {\n    ").concat(e, " = Long.fromBytesBE(buffer.slice(offset+1,offset+9));\n    if (").concat(e, ".greaterThan(Number.MAX_SAFE_INTEGER) || ").concat(e, ".lessThan(Number.MIN_SAFE_INTEGER))\n      throw new Error('integer overflow')\n    ").concat(e, " = ").concat(e, ".toNumber()\n    offset += 9;\n  }\n  "));
+        }, e.Parser = l;
+      }).call(this, r(19).Buffer);
+    }, function (module, exports) {
+      var indexOf = function (t, e) {
+        if (t.indexOf) return t.indexOf(e);
+
+        for (var r = 0; r < t.length; r++) if (t[r] === e) return r;
+
+        return -1;
+      },
+          Object_keys = function (t) {
+        if (Object.keys) return Object.keys(t);
+        var e = [];
+
+        for (var r in t) e.push(r);
+
+        return e;
+      },
+          forEach = function (t, e) {
+        if (t.forEach) return t.forEach(e);
+
+        for (var r = 0; r < t.length; r++) e(t[r], r, t);
+      },
+          defineProp = function () {
+        try {
+          return Object.defineProperty({}, "_", {}), function (t, e, r) {
+            Object.defineProperty(t, e, {
+              writable: !0,
+              enumerable: !1,
+              configurable: !0,
+              value: r
+            });
+          };
+        } catch (t) {
+          return function (t, e, r) {
+            t[e] = r;
+          };
+        }
+      }(),
+          globals = ["Array", "Boolean", "Date", "Error", "EvalError", "Function", "Infinity", "JSON", "Math", "NaN", "Number", "Object", "RangeError", "ReferenceError", "RegExp", "String", "SyntaxError", "TypeError", "URIError", "decodeURI", "decodeURIComponent", "encodeURI", "encodeURIComponent", "escape", "eval", "isFinite", "isNaN", "parseFloat", "parseInt", "undefined", "unescape"];
+
+      function Context() {}
+
+      Context.prototype = {};
+
+      var Script = exports.Script = function (t) {
+        if (!(this instanceof Script)) return new Script(t);
+        this.code = t;
+      };
+
+      Script.prototype.runInContext = function (t) {
+        if (!(t instanceof Context)) throw new TypeError("needs a 'context' argument.");
+        var e = document.createElement("iframe");
+        e.style || (e.style = {}), e.style.display = "none", document.body.appendChild(e);
+        var r = e.contentWindow,
+            n = r.eval,
+            i = r.execScript;
+        !n && i && (i.call(r, "null"), n = r.eval), forEach(Object_keys(t), function (e) {
+          r[e] = t[e];
+        }), forEach(globals, function (e) {
+          t[e] && (r[e] = t[e]);
+        });
+        var o = Object_keys(r),
+            a = n.call(r, this.code);
+        return forEach(Object_keys(r), function (e) {
+          (e in t || -1 === indexOf(o, e)) && (t[e] = r[e]);
+        }), forEach(globals, function (e) {
+          e in t || defineProp(t, e, r[e]);
+        }), document.body.removeChild(e), a;
+      }, Script.prototype.runInThisContext = function () {
+        return eval2(this.code);
+      }, Script.prototype.runInNewContext = function (t) {
+        var e = Script.createContext(t),
+            r = this.runInContext(e);
+        return t && forEach(Object_keys(e), function (r) {
+          t[r] = e[r];
+        }), r;
+      }, forEach(Object_keys(Script.prototype), function (t) {
+        exports[t] = Script[t] = function (e) {
+          var r = Script(e);
+          return r[t].apply(r, [].slice.call(arguments, 1));
+        };
+      }), exports.isContext = function (t) {
+        return t instanceof Context;
+      }, exports.createScript = function (t) {
+        return exports.Script(t);
+      }, exports.createContext = Script.createContext = function (t) {
+        var e = new Context();
+        return "object" == typeof t && forEach(Object_keys(t), function (r) {
+          e[r] = t[r];
+        }), e;
+      };
+    }, function (t, e, r) {
+
+      function n(t) {
+        return (n = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (t) {
+          return typeof t;
+        } : function (t) {
+          return t && "function" == typeof Symbol && t.constructor === Symbol && t !== Symbol.prototype ? "symbol" : typeof t;
+        })(t);
+      }
+
+      var i = function () {
+        this.code = "", this.scopes = [["vars"]], this.isAsync = !1, this.bitFields = [], this.tmpVariableCount = 0, this.references = {};
+      };
+
+      i.prototype.generateVariable = function (t) {
+        var e = [];
+
+        for (Array.prototype.push.apply(e, this.scopes[this.scopes.length - 1]); /^\$parent\./.test(t);) e.pop(), t = t.replace(/^\$parent\./, "");
+
+        return t && e.push(t), e.join(".");
+      }, i.prototype.generateOption = function (t) {
+        switch (n(t)) {
+          case "number":
+            return t.toString();
+
+          case "string":
+            return this.generateVariable(t);
+
+          case "function":
+            return "(".concat(t, ").call(").concat(this.generateVariable(), ", vars)");
+
+          default:
+            return;
+        }
+      }, i.prototype.generateError = function () {
+        var t = Array.prototype.slice.call(arguments),
+            e = i.interpolate.apply(this, t);
+        this.isAsync ? this.pushCode("return process.nextTick(function() { callback(new Error(".concat(e, "), vars); });")) : this.pushCode("throw new Error(".concat(e, ");"));
+      }, i.prototype.generateTmpVariable = function () {
+        return "$tmp".concat(this.tmpVariableCount++);
+      }, i.prototype.pushCode = function () {
+        var t = Array.prototype.slice.call(arguments);
+        this.code += "".concat(i.interpolate.apply(this, t), "\n");
+      }, i.prototype.pushPath = function (t) {
+        t && this.scopes[this.scopes.length - 1].push(t);
+      }, i.prototype.popPath = function (t) {
+        t && this.scopes[this.scopes.length - 1].pop();
+      }, i.prototype.pushScope = function (t) {
+        this.scopes.push([t]);
+      }, i.prototype.popScope = function () {
+        this.scopes.pop();
+      }, i.prototype.addReference = function (t) {
+        this.references[t] || (this.references[t] = {
+          resolved: !1,
+          requested: !1
+        });
+      }, i.prototype.markResolved = function (t) {
+        this.references[t].resolved = !0;
+      }, i.prototype.markRequested = function (t) {
+        t.forEach(function (t) {
+          this.references[t].requested = !0;
+        }.bind(this));
+      }, i.prototype.getUnresolvedReferences = function () {
+        var t = this.references;
+        return Object.keys(this.references).filter(function (e) {
+          return !t[e].resolved && !t[e].requested;
+        });
+      }, i.interpolate = function (t) {
+        var e = /{\d+}/g,
+            r = t.match(e),
+            n = Array.prototype.slice.call(arguments, 1);
+        return r && r.forEach(function (e) {
+          var r = parseInt(e.substr(1, e.length - 2), 10);
+          t = t.replace(e, n[r].toString());
+        }), t;
+      }, e.Context = i;
+    }, function (t, e, r) {
+
+      (function (e) {
+        var n,
+            i = r(1),
+            o = i(r(16)),
+            a = i(r(75)),
+            s = i(r(37)),
+            u = i(r(30)),
+            f = i(r(31)),
+            c = i(r(7)),
+            l = i(r(10)),
+            h = r(9).CramMalformedError,
+            d = r(58),
+            p = d.itf8Size,
+            g = d.parseItem,
+            v = d.tinyMemoize,
+            y = r(334),
+            m = r(390),
+            b = function () {
+          function t(e, r) {
+            (0, c.default)(this, t), this.file = e, this.filePosition = r;
+          }
+
+          var r, n, i, o;
+          return (0, l.default)(t, [{
+            key: "getHeader",
+            value: function () {
+              return this._readContainerHeader(this.filePosition);
+            }
+          }, {
+            key: "getCompressionHeaderBlock",
+            value: (o = (0, f.default)(u.default.mark(function t() {
+              var e, r, n;
+              return u.default.wrap(function (t) {
+                for (;;) switch (t.prev = t.next) {
+                  case 0:
+                    return t.next = 2, this.getHeader();
+
+                  case 2:
+                    if (t.sent.numRecords) {
+                      t.next = 5;
+                      break;
+                    }
+
+                    return t.abrupt("return", null);
+
+                  case 5:
+                    return t.next = 7, this.file.getSectionParsers();
+
+                  case 7:
+                    return e = t.sent, t.next = 10, this.getFirstBlock();
+
+                  case 10:
+                    if ("COMPRESSION_HEADER" === (r = t.sent).contentType) {
+                      t.next = 13;
+                      break;
+                    }
+
+                    throw new h("invalid content type ".concat(r.contentType, " in what is supposed to be the compression header block"));
+
+                  case 13:
+                    return n = g(r.content, e.cramCompressionHeader.parser, 0, r.contentPosition), r.content = n, t.abrupt("return", r);
+
+                  case 16:
+                  case "end":
+                    return t.stop();
+                }
+              }, t, this);
+            })), function () {
+              return o.apply(this, arguments);
+            })
+          }, {
+            key: "getFirstBlock",
+            value: (i = (0, f.default)(u.default.mark(function t() {
+              var e;
+              return u.default.wrap(function (t) {
+                for (;;) switch (t.prev = t.next) {
+                  case 0:
+                    return t.next = 2, this.getHeader();
+
+                  case 2:
+                    return e = t.sent, t.abrupt("return", this.file.readBlock(e._endPosition));
+
+                  case 4:
+                  case "end":
+                    return t.stop();
+                }
+              }, t, this);
+            })), function () {
+              return i.apply(this, arguments);
+            })
+          }, {
+            key: "getCompressionScheme",
+            value: (n = (0, f.default)(u.default.mark(function t() {
+              var e;
+              return u.default.wrap(function (t) {
+                for (;;) switch (t.prev = t.next) {
+                  case 0:
+                    return t.next = 2, this.getCompressionHeaderBlock();
+
+                  case 2:
+                    if (e = t.sent) {
+                      t.next = 5;
+                      break;
+                    }
+
+                    return t.abrupt("return", void 0);
+
+                  case 5:
+                    return t.abrupt("return", new m(e.content));
+
+                  case 6:
+                  case "end":
+                    return t.stop();
+                }
+              }, t, this);
+            })), function () {
+              return n.apply(this, arguments);
+            })
+          }, {
+            key: "getSlice",
+            value: function (t, e) {
+              return new y(this, t, e);
+            }
+          }, {
+            key: "_readContainerHeader",
+            value: (r = (0, f.default)(u.default.mark(function t(r) {
+              var n, i, o, f, c, l, h, d, v, y, m, b, _;
+
+              return u.default.wrap(function (t) {
+                for (;;) switch (t.prev = t.next) {
+                  case 0:
+                    return t.next = 2, this.file.getSectionParsers();
+
+                  case 2:
+                    return n = t.sent, i = n.cramContainerHeader1, o = n.cramContainerHeader2, t.next = 6, this.file.stat();
+
+                  case 6:
+                    if (f = t.sent, c = f.size, !(r >= c)) {
+                      t.next = 10;
+                      break;
+                    }
+
+                    return t.abrupt("return", void 0);
+
+                  case 10:
+                    return l = e.allocUnsafe(i.maxLength), t.next = 13, this.file.read(l, 0, i.maxLength, r);
+
+                  case 13:
+                    if (h = g(l, i.parser), d = p(h.numLandmarks), !(r + h.length >= c)) {
+                      t.next = 18;
+                      break;
+                    }
+
+                    return console.warn((0, s.default)(v = (0, s.default)(y = "".concat(this.file, ": container header at ")).call(y, r, " indicates that the container has length ")).call(v, h.length, ", which extends beyond the length of the file. Skipping this container.")), t.abrupt("return", void 0);
+
+                  case 18:
+                    return m = e.allocUnsafe(o.maxLength(h.numLandmarks)), t.next = 21, this.file.read(m, 0, o.maxLength(h.numLandmarks), r + h._size - d);
+
+                  case 21:
+                    if (b = g(m, o.parser), !this.file.validateChecksums || void 0 === b.crc32) {
+                      t.next = 25;
+                      break;
+                    }
+
+                    return t.next = 25, this.file.checkCrc32(r, h._size + b._size - d - 4, b.crc32, "container header beginning at position ".concat(r));
+
+                  case 25:
+                    return _ = (0, a.default)(h, b, {
+                      _size: h._size + b._size - d,
+                      _endPosition: h._size + b._size - d + r
+                    }), t.abrupt("return", _);
+
+                  case 27:
+                  case "end":
+                    return t.stop();
+                }
+              }, t, this);
+            })), function (t) {
+              return r.apply(this, arguments);
+            })
+          }]), t;
+        }();
+
+        (0, o.default)(n = "getHeader getCompressionHeaderBlock getCompressionScheme".split(" ")).call(n, function (t) {
+          return v(b, t);
+        }), t.exports = b;
+      }).call(this, r(19).Buffer);
+    }, function (t, e, r) {
+      t.exports = r(115);
+    }, function (t, e, r) {
+      var n, i, o, a, s;
+      n = r(332), i = r(147).utf8, o = r(333), a = r(147).bin, (s = function (t, e) {
+        t.constructor == String ? t = e && "binary" === e.encoding ? a.stringToBytes(t) : i.stringToBytes(t) : o(t) ? t = Array.prototype.slice.call(t, 0) : Array.isArray(t) || (t = t.toString());
+
+        for (var r = n.bytesToWords(t), u = 8 * t.length, f = 1732584193, c = -271733879, l = -1732584194, h = 271733878, d = 0; d < r.length; d++) r[d] = 16711935 & (r[d] << 8 | r[d] >>> 24) | 4278255360 & (r[d] << 24 | r[d] >>> 8);
+
+        r[u >>> 5] |= 128 << u % 32, r[14 + (u + 64 >>> 9 << 4)] = u;
+        var p = s._ff,
+            g = s._gg,
+            v = s._hh,
+            y = s._ii;
+
+        for (d = 0; d < r.length; d += 16) {
+          var m = f,
+              b = c,
+              _ = l,
+              w = h;
+          f = p(f, c, l, h, r[d + 0], 7, -680876936), h = p(h, f, c, l, r[d + 1], 12, -389564586), l = p(l, h, f, c, r[d + 2], 17, 606105819), c = p(c, l, h, f, r[d + 3], 22, -1044525330), f = p(f, c, l, h, r[d + 4], 7, -176418897), h = p(h, f, c, l, r[d + 5], 12, 1200080426), l = p(l, h, f, c, r[d + 6], 17, -1473231341), c = p(c, l, h, f, r[d + 7], 22, -45705983), f = p(f, c, l, h, r[d + 8], 7, 1770035416), h = p(h, f, c, l, r[d + 9], 12, -1958414417), l = p(l, h, f, c, r[d + 10], 17, -42063), c = p(c, l, h, f, r[d + 11], 22, -1990404162), f = p(f, c, l, h, r[d + 12], 7, 1804603682), h = p(h, f, c, l, r[d + 13], 12, -40341101), l = p(l, h, f, c, r[d + 14], 17, -1502002290), f = g(f, c = p(c, l, h, f, r[d + 15], 22, 1236535329), l, h, r[d + 1], 5, -165796510), h = g(h, f, c, l, r[d + 6], 9, -1069501632), l = g(l, h, f, c, r[d + 11], 14, 643717713), c = g(c, l, h, f, r[d + 0], 20, -373897302), f = g(f, c, l, h, r[d + 5], 5, -701558691), h = g(h, f, c, l, r[d + 10], 9, 38016083), l = g(l, h, f, c, r[d + 15], 14, -660478335), c = g(c, l, h, f, r[d + 4], 20, -405537848), f = g(f, c, l, h, r[d + 9], 5, 568446438), h = g(h, f, c, l, r[d + 14], 9, -1019803690), l = g(l, h, f, c, r[d + 3], 14, -187363961), c = g(c, l, h, f, r[d + 8], 20, 1163531501), f = g(f, c, l, h, r[d + 13], 5, -1444681467), h = g(h, f, c, l, r[d + 2], 9, -51403784), l = g(l, h, f, c, r[d + 7], 14, 1735328473), f = v(f, c = g(c, l, h, f, r[d + 12], 20, -1926607734), l, h, r[d + 5], 4, -378558), h = v(h, f, c, l, r[d + 8], 11, -2022574463), l = v(l, h, f, c, r[d + 11], 16, 1839030562), c = v(c, l, h, f, r[d + 14], 23, -35309556), f = v(f, c, l, h, r[d + 1], 4, -1530992060), h = v(h, f, c, l, r[d + 4], 11, 1272893353), l = v(l, h, f, c, r[d + 7], 16, -155497632), c = v(c, l, h, f, r[d + 10], 23, -1094730640), f = v(f, c, l, h, r[d + 13], 4, 681279174), h = v(h, f, c, l, r[d + 0], 11, -358537222), l = v(l, h, f, c, r[d + 3], 16, -722521979), c = v(c, l, h, f, r[d + 6], 23, 76029189), f = v(f, c, l, h, r[d + 9], 4, -640364487), h = v(h, f, c, l, r[d + 12], 11, -421815835), l = v(l, h, f, c, r[d + 15], 16, 530742520), f = y(f, c = v(c, l, h, f, r[d + 2], 23, -995338651), l, h, r[d + 0], 6, -198630844), h = y(h, f, c, l, r[d + 7], 10, 1126891415), l = y(l, h, f, c, r[d + 14], 15, -1416354905), c = y(c, l, h, f, r[d + 5], 21, -57434055), f = y(f, c, l, h, r[d + 12], 6, 1700485571), h = y(h, f, c, l, r[d + 3], 10, -1894986606), l = y(l, h, f, c, r[d + 10], 15, -1051523), c = y(c, l, h, f, r[d + 1], 21, -2054922799), f = y(f, c, l, h, r[d + 8], 6, 1873313359), h = y(h, f, c, l, r[d + 15], 10, -30611744), l = y(l, h, f, c, r[d + 6], 15, -1560198380), c = y(c, l, h, f, r[d + 13], 21, 1309151649), f = y(f, c, l, h, r[d + 4], 6, -145523070), h = y(h, f, c, l, r[d + 11], 10, -1120210379), l = y(l, h, f, c, r[d + 2], 15, 718787259), c = y(c, l, h, f, r[d + 9], 21, -343485551), f = f + m >>> 0, c = c + b >>> 0, l = l + _ >>> 0, h = h + w >>> 0;
+        }
+
+        return n.endian([f, c, l, h]);
+      })._ff = function (t, e, r, n, i, o, a) {
+        var s = t + (e & r | ~e & n) + (i >>> 0) + a;
+        return (s << o | s >>> 32 - o) + e;
+      }, s._gg = function (t, e, r, n, i, o, a) {
+        var s = t + (e & n | r & ~n) + (i >>> 0) + a;
+        return (s << o | s >>> 32 - o) + e;
+      }, s._hh = function (t, e, r, n, i, o, a) {
+        var s = t + (e ^ r ^ n) + (i >>> 0) + a;
+        return (s << o | s >>> 32 - o) + e;
+      }, s._ii = function (t, e, r, n, i, o, a) {
+        var s = t + (r ^ (e | ~n)) + (i >>> 0) + a;
+        return (s << o | s >>> 32 - o) + e;
+      }, s._blocksize = 16, s._digestsize = 16, t.exports = function (t, e) {
+        if (null == t) throw new Error("Illegal argument " + t);
+        var r = n.wordsToBytes(s(t, e));
+        return e && e.asBytes ? r : e && e.asString ? a.bytesToString(r) : n.bytesToHex(r);
+      };
+    }, function (t, e) {
+      var r, n;
+      r = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/", n = {
+        rotl: function (t, e) {
+          return t << e | t >>> 32 - e;
+        },
+        rotr: function (t, e) {
+          return t << 32 - e | t >>> e;
+        },
+        endian: function (t) {
+          if (t.constructor == Number) return 16711935 & n.rotl(t, 8) | 4278255360 & n.rotl(t, 24);
+
+          for (var e = 0; e < t.length; e++) t[e] = n.endian(t[e]);
+
+          return t;
+        },
+        randomBytes: function (t) {
+          for (var e = []; t > 0; t--) e.push(Math.floor(256 * Math.random()));
+
+          return e;
+        },
+        bytesToWords: function (t) {
+          for (var e = [], r = 0, n = 0; r < t.length; r++, n += 8) e[n >>> 5] |= t[r] << 24 - n % 32;
+
+          return e;
+        },
+        wordsToBytes: function (t) {
+          for (var e = [], r = 0; r < 32 * t.length; r += 8) e.push(t[r >>> 5] >>> 24 - r % 32 & 255);
+
+          return e;
+        },
+        bytesToHex: function (t) {
+          for (var e = [], r = 0; r < t.length; r++) e.push((t[r] >>> 4).toString(16)), e.push((15 & t[r]).toString(16));
+
+          return e.join("");
+        },
+        hexToBytes: function (t) {
+          for (var e = [], r = 0; r < t.length; r += 2) e.push(parseInt(t.substr(r, 2), 16));
+
+          return e;
+        },
+        bytesToBase64: function (t) {
+          for (var e = [], n = 0; n < t.length; n += 3) for (var i = t[n] << 16 | t[n + 1] << 8 | t[n + 2], o = 0; o < 4; o++) 8 * n + 6 * o <= 8 * t.length ? e.push(r.charAt(i >>> 6 * (3 - o) & 63)) : e.push("=");
+
+          return e.join("");
+        },
+        base64ToBytes: function (t) {
+          t = t.replace(/[^A-Z0-9+\/]/gi, "");
+
+          for (var e = [], n = 0, i = 0; n < t.length; i = ++n % 4) 0 != i && e.push((r.indexOf(t.charAt(n - 1)) & Math.pow(2, -2 * i + 8) - 1) << 2 * i | r.indexOf(t.charAt(n)) >>> 6 - 2 * i);
+
+          return e;
+        }
+      }, t.exports = n;
+    }, function (t, e) {
+      function r(t) {
+        return !!t.constructor && "function" == typeof t.constructor.isBuffer && t.constructor.isBuffer(t);
+      }
+      /*!
+       * Determine if an object is a Buffer
+       *
+       * @author   Feross Aboukhadijeh <https://feross.org>
+       * @license  MIT
+       */
+
+
+      t.exports = function (t) {
+        return null != t && (r(t) || function (t) {
+          return "function" == typeof t.readFloatLE && "function" == typeof t.slice && r(t.slice(0, 0));
+        }(t) || !!t._isBuffer);
+      };
+    }, function (t, e, r) {
+
+      var n,
+          i = r(1),
+          o = i(r(148)),
+          a = i(r(76)),
+          s = i(r(150)),
+          u = i(r(37)),
+          f = i(r(30)),
+          c = i(r(31)),
+          l = i(r(7)),
+          h = i(r(10)),
+          d = i(r(99)),
+          p = i(r(16)),
+          g = i(r(77)),
+          v = i(r(59)),
+          y = r(9),
+          m = y.CramMalformedError,
+          b = y.CramBufferOverrunError,
+          _ = y.CramArgumentError,
+          w = r(58),
+          x = w.parseItem,
+          E = w.tinyMemoize,
+          S = w.sequenceMD5,
+          k = r(100),
+          A = r(363);
+
+      function C(t, e, r, n) {
+        if (!n) throw new m("could not resolve intra-slice mate pairs, file seems truncated or malformed");
+        var i = !!(n.mate || void 0 !== n.mateRecordNumber && n.mateRecordNumber !== e);
+        r.readName || (r.readName = String(r.uniqueId), n.readName = r.readName), r.mate = {
+          sequenceId: n.sequenceId,
+          alignmentStart: n.alignmentStart,
+          uniqueId: n.uniqueId
+        }, n.readName && (r.mate.readName = n.readName), n.mate || void 0 !== n.mateRecordNumber || (n.mate = {
+          sequenceId: r.sequenceId,
+          alignmentStart: r.alignmentStart,
+          uniqueId: r.uniqueId
+        }, r.readName && (n.mate.readName = r.readName)), r.flags |= k.BAM_FPAIRED, (0, d.default)(n) & k.BAM_FUNMAP && (r.flags |= k.BAM_FMUNMAP), (0, d.default)(r) & k.BAM_FUNMAP && (n.flags |= k.BAM_FMUNMAP), (0, d.default)(n) & k.BAM_FREVERSE && (r.flags |= k.BAM_FMREVERSE), (0, d.default)(r) & k.BAM_FREVERSE && (n.flags |= k.BAM_FMREVERSE), void 0 === r.templateLength && (i ? function (t, e, r) {
+          var n = function e(r) {
+            var n = [r];
+
+            if (r.mateRecordNumber >= 0) {
+              var i = t[r.mateRecordNumber];
+              if (!i) throw new m("intra-slice mate record not found, this file seems malformed");
+              n.push.apply(n, (0, v.default)(e(i)));
+            }
+
+            return n;
+          }(r),
+              i = (0, g.default)(n).call(n, function (t) {
+            return t.alignmentStart;
+          }),
+              o = (0, g.default)(n).call(n, function (t) {
+            return t.alignmentStart + t.readLength - 1;
+          }),
+              a = Math.max.apply(Math, (0, v.default)(o)) - Math.min.apply(Math, (0, v.default)(i)) + 1;
+
+          a >= 0 && (0, p.default)(n).call(n, function (t) {
+            if (void 0 !== t.templateLength) throw new m("mate pair group has some members that have template lengths already, this file seems malformed");
+            t.templateLength = a;
+          });
+        }(t, 0, r) : function (t, e) {
+          var r = Math.min(t.alignmentStart, e.alignmentStart),
+              n = Math.max(t.alignmentStart + t.readLength - 1, e.alignmentStart + e.readLength - 1) - r + 1;
+          t.templateLength = n, e.templateLength = n;
+        }(r, n)), delete r.mateRecordNumber;
+      }
+
+      var T = function () {
+        function t(e, r) {
+          (0, l.default)(this, t), this.container = e, this.file = e.file, this.containerPosition = r;
+        }
+
+        var e, r, n, i, d, v, y, w;
+        return (0, h.default)(t, [{
+          key: "getHeader",
+          value: (w = (0, c.default)(f.default.mark(function t() {
+            var e, r, n;
+            return f.default.wrap(function (t) {
+              for (;;) switch (t.prev = t.next) {
+                case 0:
+                  return t.next = 2, this.file.getSectionParsers();
+
+                case 2:
+                  return e = t.sent, t.next = 5, this.container.getHeader();
+
+                case 5:
+                  return r = t.sent, t.next = 8, this.file.readBlock(r._endPosition + this.containerPosition);
+
+                case 8:
+                  if ("MAPPED_SLICE_HEADER" !== (n = t.sent).contentType) {
+                    t.next = 13;
+                    break;
+                  }
+
+                  n.content = x(n.content, e.cramMappedSliceHeader.parser, 0, r._endPosition), t.next = 18;
+                  break;
+
+                case 13:
+                  if ("UNMAPPED_SLICE_HEADER" !== n.contentType) {
+                    t.next = 17;
+                    break;
+                  }
+
+                  n.content = x(n.content, e.cramUnmappedSliceHeader.parser, 0, r._endPosition), t.next = 18;
+                  break;
+
+                case 17:
+                  throw new m("error reading slice header block, invalid content type ".concat(n._contentType));
+
+                case 18:
+                  return t.abrupt("return", n);
+
+                case 19:
+                case "end":
+                  return t.stop();
+              }
+            }, t, this);
+          })), function () {
+            return w.apply(this, arguments);
+          })
+        }, {
+          key: "getBlocks",
+          value: (y = (0, c.default)(f.default.mark(function t() {
+            var e, r, n, i;
+            return f.default.wrap(function (t) {
+              for (;;) switch (t.prev = t.next) {
+                case 0:
+                  return t.next = 2, this.getHeader();
+
+                case 2:
+                  e = t.sent, r = e._endPosition, n = new Array(e.content.numBlocks), i = 0;
+
+                case 6:
+                  if (!(i < n.length)) {
+                    t.next = 14;
+                    break;
+                  }
+
+                  return t.next = 9, this.file.readBlock(r);
+
+                case 9:
+                  n[i] = t.sent, r = n[i]._endPosition;
+
+                case 11:
+                  i += 1, t.next = 6;
+                  break;
+
+                case 14:
+                  return t.abrupt("return", n);
+
+                case 15:
+                case "end":
+                  return t.stop();
+              }
+            }, t, this);
+          })), function () {
+            return y.apply(this, arguments);
+          })
+        }, {
+          key: "getCoreDataBlock",
+          value: (v = (0, c.default)(f.default.mark(function t() {
+            var e;
+            return f.default.wrap(function (t) {
+              for (;;) switch (t.prev = t.next) {
+                case 0:
+                  return t.next = 2, this.getBlocks();
+
+                case 2:
+                  return e = t.sent, t.abrupt("return", e[0]);
+
+                case 4:
+                case "end":
+                  return t.stop();
+              }
+            }, t, this);
+          })), function () {
+            return v.apply(this, arguments);
+          })
+        }, {
+          key: "_getBlocksContentIdIndex",
+          value: (d = (0, c.default)(f.default.mark(function t() {
+            var e, r;
+            return f.default.wrap(function (t) {
+              for (;;) switch (t.prev = t.next) {
+                case 0:
+                  return t.next = 2, this.getBlocks();
+
+                case 2:
+                  return e = t.sent, r = {}, (0, p.default)(e).call(e, function (t) {
+                    "EXTERNAL_DATA" === t.contentType && (r[t.contentId] = t);
+                  }), t.abrupt("return", r);
+
+                case 6:
+                case "end":
+                  return t.stop();
+              }
+            }, t, this);
+          })), function () {
+            return d.apply(this, arguments);
+          })
+        }, {
+          key: "getBlockByContentId",
+          value: (i = (0, c.default)(f.default.mark(function t(e) {
+            var r;
+            return f.default.wrap(function (t) {
+              for (;;) switch (t.prev = t.next) {
+                case 0:
+                  return t.next = 2, this._getBlocksContentIdIndex();
+
+                case 2:
+                  return r = t.sent, t.abrupt("return", r[e]);
+
+                case 4:
+                case "end":
+                  return t.stop();
+              }
+            }, t, this);
+          })), function (t) {
+            return i.apply(this, arguments);
+          })
+        }, {
+          key: "getReferenceRegion",
+          value: (n = (0, c.default)(f.default.mark(function t() {
+            var e, r, n, i;
+            return f.default.wrap(function (t) {
+              for (;;) switch (t.prev = t.next) {
+                case 0:
+                  return t.next = 2, this.getHeader();
+
+                case 2:
+                  if (!((e = t.sent.content).refSeqId < 0)) {
+                    t.next = 5;
+                    break;
+                  }
+
+                  return t.abrupt("return", void 0);
+
+                case 5:
+                  return t.next = 7, this.container.getCompressionScheme();
+
+                case 7:
+                  if (r = t.sent, !(e.refBaseBlockId >= 0)) {
+                    t.next = 15;
+                    break;
+                  }
+
+                  if (n = this.getBlockByContentId(e.refBaseBlockId)) {
+                    t.next = 12;
+                    break;
+                  }
+
+                  throw new m("embedded reference specified, but reference block does not exist");
+
+                case 12:
+                  if (!(e.span > n.uncompressedSize)) {
+                    t.next = 14;
+                    break;
+                  }
+
+                  throw new m("Embedded reference is too small");
+
+                case 14:
+                  return t.abrupt("return", {
+                    seq: n.data.toString("utf8"),
+                    start: e.refSeqStart,
+                    end: e.refSeqStart + e.refSeqSpan - 1,
+                    span: e.refSeqSpan
+                  });
+
+                case 15:
+                  if (!r.referenceRequired && !this.file.fetchReferenceSequenceCallback) {
+                    t.next = 24;
+                    break;
+                  }
+
+                  if (this.file.fetchReferenceSequenceCallback) {
+                    t.next = 18;
+                    break;
+                  }
+
+                  throw new Error("reference sequence not embedded, and seqFetch callback not provided, cannot fetch reference sequence");
+
+                case 18:
+                  return t.next = 20, this.file.fetchReferenceSequenceCallback(e.refSeqId, e.refSeqStart, e.refSeqStart + e.refSeqSpan - 1);
+
+                case 20:
+                  if ((i = t.sent).length === e.refSeqSpan) {
+                    t.next = 23;
+                    break;
+                  }
+
+                  throw new _("seqFetch callback returned a reference sequence of the wrong length");
+
+                case 23:
+                  return t.abrupt("return", {
+                    seq: i,
+                    start: e.refSeqStart,
+                    end: e.refSeqStart + e.refSeqSpan - 1,
+                    span: e.refSeqSpan
+                  });
+
+                case 24:
+                  return t.abrupt("return", void 0);
+
+                case 25:
+                case "end":
+                  return t.stop();
+              }
+            }, t, this);
+          })), function () {
+            return n.apply(this, arguments);
+          })
+        }, {
+          key: "getAllRecords",
+          value: function () {
+            return this.getRecords(function () {
+              return !0;
+            });
+          }
+        }, {
+          key: "_fetchRecords",
+          value: (r = (0, c.default)(f.default.mark(function t() {
+            var e,
+                r,
+                n,
+                i,
+                o,
+                a,
+                c,
+                l,
+                h,
+                d,
+                p,
+                v,
+                y,
+                _,
+                w,
+                x,
+                E,
+                k,
+                T,
+                R,
+                O,
+                I,
+                L,
+                B = this;
+
+            return f.default.wrap(function (t) {
+              for (;;) switch (t.prev = t.next) {
+                case 0:
+                  return t.next = 2, this.file.getDefinition();
+
+                case 2:
+                  return e = t.sent, r = e.majorVersion, t.next = 6, this.container.getCompressionScheme();
+
+                case 6:
+                  return n = t.sent, t.next = 9, this.getHeader();
+
+                case 9:
+                  return i = t.sent, t.next = 12, this._getBlocksContentIdIndex();
+
+                case 12:
+                  if (o = t.sent, !(r > 1 && this.file.options.checkSequenceMD5 && i.content.refSeqId >= 0 && "0000000000000000" !== i.content.md5.join(""))) {
+                    t.next = 23;
+                    break;
+                  }
+
+                  return t.next = 16, this.getReferenceRegion();
+
+                case 16:
+                  if (!(a = t.sent)) {
+                    t.next = 23;
+                    break;
+                  }
+
+                  if (v = a.seq, y = a.start, _ = a.end, w = S(v), x = (0, g.default)(c = i.content.md5).call(c, function (t) {
+                    return (t < 16 ? "0" : "") + t.toString(16);
+                  }).join(""), w === x) {
+                    t.next = 23;
+                    break;
+                  }
+
+                  throw new m((0, u.default)(l = (0, u.default)(h = (0, u.default)(d = (0, u.default)(p = "MD5 checksum reference mismatch for ref ".concat(i.content.refSeqId, " pos ")).call(p, y, "..")).call(d, _, ". recorded MD5: ")).call(h, x, ", calculated MD5: ")).call(l, w));
+
+                case 23:
+                  return t.next = 25, this.getCoreDataBlock();
+
+                case 25:
+                  E = t.sent, k = {
+                    lastAlignmentStart: i.content.refSeqStart || 0,
+                    coreBlock: {
+                      bitPosition: 7,
+                      bytePosition: 0
+                    },
+                    externalBlocks: {
+                      getCursor: function (t) {
+                        return this[t] || (this[t] = {
+                          bitPosition: 7,
+                          bytePosition: 0
+                        }), this[t];
+                      }
+                    }
+                  }, T = function (t) {
+                    var e = n.getCodecForDataSeries(t);
+                    if (!e) throw new m("no codec defined for ".concat(t, " data series"));
+                    return e.decode(B, E, o, k);
+                  }, R = new Array(i.content.numRecords), O = 0;
+
+                case 30:
+                  if (!(O < R.length)) {
+                    t.next = 48;
+                    break;
+                  }
+
+                  t.prev = 31, R[O] = A(this, T, n, i, E, o, k, r, O), R[O].uniqueId = i.contentPosition + i.content.recordCounter + O + 1, t.next = 45;
+                  break;
+
+                case 36:
+                  if (t.prev = 36, t.t0 = t.catch(31), !(t.t0 instanceof b)) {
+                    t.next = 44;
+                    break;
+                  }
+
+                  return console.warn("read attempted beyond end of buffer, file seems truncated."), R = (0, s.default)(R).call(R, function (t) {
+                    return !!t;
+                  }), t.abrupt("break", 48);
+
+                case 44:
+                  throw t.t0;
+
+                case 45:
+                  O += 1, t.next = 30;
+                  break;
+
+                case 48:
+                  for (I = 0; I < R.length; I += 1) (L = R[I].mateRecordNumber) >= 0 && C(R, I, R[I], R[L]);
+
+                  return t.abrupt("return", R);
+
+                case 50:
+                case "end":
+                  return t.stop();
+              }
+            }, t, this, [[31, 36]]);
+          })), function () {
+            return r.apply(this, arguments);
+          })
+        }, {
+          key: "getRecords",
+          value: (e = (0, c.default)(f.default.mark(function t(e) {
+            var r,
+                n,
+                i,
+                u,
+                l,
+                h,
+                d,
+                p,
+                v,
+                y,
+                m,
+                b,
+                _,
+                w,
+                x,
+                E,
+                S = this;
+
+            return f.default.wrap(function (t) {
+              for (;;) switch (t.prev = t.next) {
+                case 0:
+                  return n = this.container.filePosition + this.containerPosition, (i = this.file.featureCache.get(n)) || (i = this._fetchRecords(), this.file.featureCache.set(n, i)), t.t0 = s.default, t.next = 6, i;
+
+                case 6:
+                  if (t.t1 = r = t.sent, t.t2 = r, t.t3 = e, !(u = (0, t.t0)(t.t1).call(t.t2, t.t3)).length || !this.file.fetchReferenceSequenceCallback) {
+                    t.next = 24;
+                    break;
+                  }
+
+                  return t.next = 13, this.getHeader();
+
+                case 13:
+                  if (!((l = t.sent).content.refSeqId >= 0 || -2 === l.content.refSeqId)) {
+                    t.next = 24;
+                    break;
+                  }
+
+                  return d = l.content.refSeqId >= 0 ? l.content.refSeqId : void 0, t.next = 18, this.container.getCompressionScheme();
+
+                case 18:
+                  for (p = t.sent, v = {}, y = 0; y < u.length; y += 1) m = void 0 !== d ? d : u[y].sequenceId, (b = v[m]) || (b = {
+                    id: m,
+                    start: u[y].alignmentStart,
+                    end: -1 / 0
+                  }, v[m] = b), (_ = u[y].alignmentStart + (u[y].lengthOnRef || u[y].readLength) - 1) > b.end && (b.end = _), u[y].alignmentStart < b.start && (b.start = u[y].alignmentStart);
+
+                  return t.next = 23, a.default.all((0, g.default)(h = (0, o.default)(v)).call(h, function () {
+                    var t = (0, c.default)(f.default.mark(function t(e) {
+                      return f.default.wrap(function (t) {
+                        for (;;) switch (t.prev = t.next) {
+                          case 0:
+                            if (!(-1 !== e.id && e.start <= e.end)) {
+                              t.next = 4;
+                              break;
+                            }
+
+                            return t.next = 3, S.file.fetchReferenceSequenceCallback(e.id, e.start, e.end);
+
+                          case 3:
+                            e.seq = t.sent;
+
+                          case 4:
+                          case "end":
+                            return t.stop();
+                        }
+                      }, t);
+                    }));
+                    return function (e) {
+                      return t.apply(this, arguments);
+                    };
+                  }()));
+
+                case 23:
+                  for (w = 0; w < u.length; w += 1) x = void 0 !== d ? d : u[w].sequenceId, (E = v[x]) && E.seq && u[w].addReferenceSequence(E, p);
+
+                case 24:
+                  return t.abrupt("return", u);
+
+                case 25:
+                case "end":
+                  return t.stop();
+              }
+            }, t, this);
+          })), function (t) {
+            return e.apply(this, arguments);
+          })
+        }]), t;
+      }();
+
+      (0, p.default)(n = "getHeader getBlocks _getBlocksContentIdIndex".split(" ")).call(n, function (t) {
+        return E(T, t);
+      }), t.exports = T;
+    }, function (t, e, r) {
+      t.exports = r(336);
+    }, function (t, e, r) {
+      r(337);
+      var n = r(3);
+      t.exports = n.Object.values;
+    }, function (t, e, r) {
+      var n = r(0),
+          i = r(149).values;
+      n({
+        target: "Object",
+        stat: !0
+      }, {
+        values: function (t) {
+          return i(t);
+        }
+      });
+    }, function (t, e, r) {
+      t.exports = r(339);
+    }, function (t, e, r) {
+      var n = r(340),
+          i = Array.prototype;
+
+      t.exports = function (t) {
+        var e = t.filter;
+        return t === i || t instanceof Array && e === i.filter ? n : e;
+      };
+    }, function (t, e, r) {
+      r(341);
+      var n = r(18);
+      t.exports = n("Array").filter;
+    }, function (t, e, r) {
+
+      var n = r(0),
+          i = r(45).filter;
+      n({
+        target: "Array",
+        proto: !0,
+        forced: !r(68)("filter")
+      }, {
+        filter: function (t) {
+          return i(this, t, arguments.length > 1 ? arguments[1] : void 0);
+        }
+      });
+    }, function (t, e, r) {
+      t.exports = r(343);
+    }, function (t, e, r) {
+      var n = r(344),
+          i = RegExp.prototype;
+
+      t.exports = function (t) {
+        return !(t === i || t instanceof RegExp) || "flags" in t ? t.flags : n(t);
+      };
+    }, function (t, e, r) {
+      r(345);
+      var n = r(346);
+
+      t.exports = function (t) {
+        return n.call(t);
+      };
+    }, function (t, e) {}, function (t, e, r) {
+
+      var n = r(2);
+
+      t.exports = function () {
+        var t = n(this),
+            e = "";
+        return t.global && (e += "g"), t.ignoreCase && (e += "i"), t.multiline && (e += "m"), t.dotAll && (e += "s"), t.unicode && (e += "u"), t.sticky && (e += "y"), e;
+      };
+    }, function (t, e, r) {
+      t.exports = r(348);
+    }, function (t, e, r) {
+      var n = r(349),
+          i = Array.prototype;
+
+      t.exports = function (t) {
+        var e = t.map;
+        return t === i || t instanceof Array && e === i.map ? n : e;
+      };
+    }, function (t, e, r) {
+      r(350);
+      var n = r(18);
+      t.exports = n("Array").map;
+    }, function (t, e, r) {
+
+      var n = r(0),
+          i = r(45).map;
+      n({
+        target: "Array",
+        proto: !0,
+        forced: !r(68)("map")
+      }, {
+        map: function (t) {
+          return i(this, t, arguments.length > 1 ? arguments[1] : void 0);
+        }
+      });
+    }, function (t, e, r) {
+      var n = r(151);
+
+      t.exports = function (t) {
+        if (n(t)) {
+          for (var e = 0, r = new Array(t.length); e < t.length; e++) r[e] = t[e];
+
+          return r;
+        }
+      };
+    }, function (t, e, r) {
+      t.exports = r(353);
+    }, function (t, e, r) {
+      r(354);
+      var n = r(3);
+      t.exports = n.Array.isArray;
+    }, function (t, e, r) {
+      r(0)({
+        target: "Array",
+        stat: !0
+      }, {
+        isArray: r(53)
+      });
+    }, function (t, e, r) {
+      t.exports = r(356);
+    }, function (t, e, r) {
+      t.exports = r(357);
+    }, function (t, e, r) {
+      r(46), r(358);
+      var n = r(3);
+      t.exports = n.Array.from;
+    }, function (t, e, r) {
+      var n = r(0),
+          i = r(359);
+      n({
+        target: "Array",
+        stat: !0,
+        forced: !r(121)(function (t) {
+          Array.from(t);
+        })
+      }, {
+        from: i
+      });
+    }, function (t, e, r) {
+
+      var n = r(15),
+          i = r(22),
+          o = r(120),
+          a = r(119),
+          s = r(29),
+          u = r(87),
+          f = r(90);
+
+      t.exports = function (t) {
+        var e,
+            r,
+            c,
+            l,
+            h = i(t),
+            d = "function" == typeof this ? this : Array,
+            p = arguments.length,
+            g = p > 1 ? arguments[1] : void 0,
+            v = void 0 !== g,
+            y = 0,
+            m = f(h);
+        if (v && (g = n(g, p > 2 ? arguments[2] : void 0, 2)), null == m || d == Array && a(m)) for (r = new d(e = s(h.length)); e > y; y++) u(r, y, v ? g(h[y], y) : h[y]);else for (l = m.call(h), r = new d(); !(c = l.next()).done; y++) u(r, y, v ? o(l, g, [c.value, y], !0) : c.value);
+        return r.length = y, r;
+      };
+    }, function (t, e, r) {
+      r(41), r(46), t.exports = r(361);
+    }, function (t, e, r) {
+      var n = r(67),
+          i = r(6),
+          o = r(35),
+          a = i("iterator");
+
+      t.exports = function (t) {
+        var e = Object(t);
+        return void 0 !== e[a] || "@@iterator" in e || o.hasOwnProperty(n(e));
+      };
+    }, function (t, e) {
+      t.exports = function () {
+        throw new TypeError("Invalid attempt to spread non-iterable instance");
+      };
+    }, function (t, e, r) {
+
+      (function (e) {
+        var n = r(1),
+            i = n(r(37)),
+            o = n(r(364)),
+            a = n(r(16)),
+            s = n(r(99)),
+            u = n(r(101)),
+            f = n(r(59)),
+            c = n(r(154)),
+            l = n(r(376)),
+            h = n(r(380)),
+            d = n(r(48)),
+            p = n(r(387)),
+            g = r(146),
+            v = r(9),
+            y = v.CramMalformedError,
+            m = v.CramUnimplementedError,
+            b = r(389),
+            _ = r(100);
+
+        function w(t) {
+          var e = (0, p.default)(t).call(t, 0);
+          return -1 === e ? t.toString("utf8") : t.toString("utf8", 0, e);
+        }
+
+        function x(t, r) {
+          if (r.readInt32LE || (r = e.from(r)), "Z" === t) return w(r);
+          if ("A" === t) return String.fromCharCode(r[0]);
+
+          if ("I" === t) {
+            var n = g.fromBytesLE(r);
+            if (n.greaterThan(h.default) || n.lessThan(l.default)) throw new m("integer overflow");
+            return n.toNumber();
+          }
+
+          if ("i" === t) return r.readInt32LE(0);
+          if ("s" === t) return r.readInt16LE(0);
+          if ("S" === t) return r.readUInt16LE(0);
+          if ("c" === t) return r.readInt8(0);
+          if ("C" === t) return r.readUInt8(0);
+          if ("f" === t) return r.readFloatLE(0);
+
+          if ("H" === t) {
+            var i = w(r);
+            return (0, c.default)(i.replace(/^0x/, ""), 16);
+          }
+
+          if ("B" === t) return function (t) {
+            var e = String.fromCharCode(t[0]),
+                r = t.readInt32LE(1),
+                n = {
+              c: ["readInt8", 1],
+              C: ["readUInt8", 1],
+              s: ["readInt16LE", 2],
+              S: ["readUInt16LE", 2],
+              i: ["readInt32LE", 4],
+              I: ["readUInt32LE", 4],
+              f: ["readFloatLE", 4]
+            }[e];
+            if (!n) throw new y("invalid tag value array type '".concat(e, "'"));
+
+            for (var i = (0, d.default)(n, 2), o = i[0], a = i[1], s = new Array(r), u = 5, f = 0; f < r; f += 1) s[f] = t[o](u), u += a;
+
+            return s;
+          }(r);
+          throw new y("Unrecognized tag type ".concat(t));
+        }
+
+        function E(t) {
+          if (t instanceof e) return w(t);
+
+          if (t.length && (0, p.default)(t)) {
+            if (!t[t.length - 1]) {
+              var r = (0, p.default)(t).call(t, 0);
+              return String.fromCharCode.apply(String, (0, f.default)((0, u.default)(t).call(t, 0, r)));
+            }
+
+            return String.fromCharCode.apply(String, (0, f.default)(t));
+          }
+
+          return String(t);
+        }
+
+        t.exports = function (t, e, r, n, u, f, c, l, h) {
+          var p = new b();
+
+          if (p.flags = e("BF"), p.cramFlags = e("CF"), l > 1 && -2 === n.content.refSeqId ? p.sequenceId = e("RI") : p.sequenceId = n.content.refSeqId, p.readLength = e("RL"), p.alignmentStart = e("AP"), r.APdelta && (p.alignmentStart += c.lastAlignmentStart), c.lastAlignmentStart = p.alignmentStart, p.readGroupId = e("RG"), r.readNamesIncluded && (p.readName = E(e("RN"))), p.isDetached()) {
+            var g = {};
+            g.flags = e("MF"), r.readNamesIncluded || (g.readName = E(e("RN")), p.readName = g.readName), g.sequenceId = e("NS"), g.alignmentStart = e("NP"), ((0, s.default)(g) || g.sequenceId > -1) && (p.mate = g), p.templateSize = e("TS"), (0, s.default)(g) & _.CRAM_M_UNMAP && (p.flags |= _.BAM_FMUNMAP), (0, s.default)(g) & _.CRAM_M_REVERSE && (p.flags |= _.BAM_FMREVERSE);
+          } else p.hasMateDownStream() && (p.mateRecordNumber = e("NF") + h + 1);
+
+          var v = e("TL");
+          if (v < 0) throw new y("invalid TL index");
+
+          for (var m = r.getTagNames(v), w = m.length, S = 0; S < w; S += 1) {
+            var k = m[S],
+                A = k.substr(0, 2),
+                C = k.substr(2, 1),
+                T = r.getCodecForTag(k);
+            if (!T) throw new y("no codec defined for auxiliary tag ".concat(k));
+            var R = T.decode(t, u, f, c);
+            p.tags[A] = x(C, R);
+          }
+
+          if (p.isSegmentUnmapped()) {
+            if (p.isUnknownBases()) p.readBases = null, p.qualityScores = null;else {
+              for (var O = new Array(p.readLength), I = 0; I < O.length; I += 1) O[I] = e("BA");
+
+              if (p.readBases = String.fromCharCode.apply(String, O), p.isPreservingQualityScores()) {
+                for (var L = 0; L < O.length; L += 1) O[L] = e("QS");
+
+                p.qualityScores = O;
+              }
+            }
+          } else {
+            var B,
+                P = e("FN");
+            P && (p.readFeatures = function (t, e, r, n, i) {
+              var o = 0,
+                  a = t.alignmentStart - 1,
+                  s = new Array(e);
+
+              function u(t) {
+                var e = (0, d.default)(t, 2),
+                    n = e[0],
+                    i = e[1],
+                    o = r(i);
+                return "character" === n ? String.fromCharCode(o) : "string" === n ? o.toString("utf8") : "numArray" === n ? o.toArray() : o;
+              }
+
+              for (var f = 0; f < e; f += 1) {
+                var c = String.fromCharCode(r("FC")),
+                    l = r("FP"),
+                    h = {
+                  code: c
+                },
+                    p = {
+                  B: ["character", "BA"],
+                  S: ["string", i > 1 ? "SC" : "IN"],
+                  X: ["number", "BS"],
+                  D: ["number", "DL"],
+                  I: ["string", "IN"],
+                  i: ["character", "BA"],
+                  b: ["string", "BB"],
+                  q: ["numArray", "QQ"],
+                  Q: ["number", "QS"],
+                  H: ["number", "HC"],
+                  P: ["number", "PD"],
+                  N: ["number", "RS"]
+                }[c];
+                if (!p) throw new y('invalid read feature code "'.concat(c, '"'));
+                h.data = u(p);
+                var g = {
+                  B: ["number", "QS"]
+                }[c];
+                g && (h.data = [h.data, u(g)]), o += l, h.pos = o, a += l, h.refPos = a, "D" === c || "N" === c ? a += h.data : "I" === c || "S" === c ? a -= h.data.length : "i" === c && (a -= 1), s[f] = h;
+              }
+
+              return s;
+            }(p, P, e, 0, l));
+            var F,
+                N = p.readLength;
+            if (p.readFeatures && (0, a.default)(B = p.readFeatures).call(B, function (t) {
+              var e = t.code,
+                  r = t.data;
+              "D" === e || "N" === e ? N += r : "I" === e || "S" === e ? N -= r.length : "i" === e && (N -= 1);
+            }), (0, o.default)(N)) console.warn("".concat(p.readName || (0, i.default)(F = "".concat(p.sequenceId, ":")).call(F, p.alignmentStart), " record has invalid read features")), N = p.readLength;
+
+            if (p.lengthOnRef = N, p.mappingQuality = e("MQ"), p.isPreservingQualityScores()) {
+              for (var M = new Array(p.readLength), j = 0; j < M.length; j += 1) M[j] = e("QS");
+
+              p.qualityScores = M;
+            }
+          }
+          return p;
+        };
+      }).call(this, r(19).Buffer);
+    }, function (t, e, r) {
+      t.exports = r(365);
+    }, function (t, e, r) {
+      t.exports = r(366);
+    }, function (t, e, r) {
+      r(367);
+      var n = r(3);
+      t.exports = n.Number.isNaN;
+    }, function (t, e, r) {
+      r(0)({
+        target: "Number",
+        stat: !0
+      }, {
+        isNaN: function (t) {
+          return t != t;
+        }
+      });
+    }, function (t, e, r) {
+      t.exports = r(369);
+    }, function (t, e, r) {
+      var n = r(370),
+          i = Array.prototype;
+
+      t.exports = function (t) {
+        var e = t.slice;
+        return t === i || t instanceof Array && e === i.slice ? n : e;
+      };
+    }, function (t, e, r) {
+      r(371);
+      var n = r(18);
+      t.exports = n("Array").slice;
+    }, function (t, e, r) {
+
+      var n = r(0),
+          i = r(14),
+          o = r(53),
+          a = r(84),
+          s = r(29),
+          u = r(28),
+          f = r(87),
+          c = r(68),
+          l = r(6)("species"),
+          h = [].slice,
+          d = Math.max;
+      n({
+        target: "Array",
+        proto: !0,
+        forced: !c("slice")
+      }, {
+        slice: function (t, e) {
+          var r,
+              n,
+              c,
+              p = u(this),
+              g = s(p.length),
+              v = a(t, g),
+              y = a(void 0 === e ? g : e, g);
+          if (o(p) && ("function" != typeof (r = p.constructor) || r !== Array && !o(r.prototype) ? i(r) && null === (r = r[l]) && (r = void 0) : r = void 0, r === Array || void 0 === r)) return h.call(p, v, y);
+
+          for (n = new (void 0 === r ? Array : r)(d(y - v, 0)), c = 0; v < y; v++, c++) v in p && f(n, c, p[v]);
+
+          return n.length = c, n;
+        }
+      });
+    }, function (t, e, r) {
+      t.exports = r(373);
+    }, function (t, e, r) {
+      r(374);
+      var n = r(3);
+      t.exports = n.Number.parseInt;
+    }, function (t, e, r) {
+      var n = r(0),
+          i = r(155);
+      n({
+        target: "Number",
+        stat: !0,
+        forced: Number.parseInt != i
+      }, {
+        parseInt: i
+      });
+    }, function (t, e, r) {
+      var n = r(49),
+          i = "[" + r(156) + "]",
+          o = RegExp("^" + i + i + "*"),
+          a = RegExp(i + i + "*$"),
+          s = function (t) {
+        return function (e) {
+          var r = String(n(e));
+          return 1 & t && (r = r.replace(o, "")), 2 & t && (r = r.replace(a, "")), r;
+        };
+      };
+
+      t.exports = {
+        start: s(1),
+        end: s(2),
+        trim: s(3)
+      };
+    }, function (t, e, r) {
+      t.exports = r(377);
+    }, function (t, e, r) {
+      t.exports = r(378);
+    }, function (t, e, r) {
+      r(379), t.exports = -9007199254740991;
+    }, function (t, e, r) {
+      r(0)({
+        target: "Number",
+        stat: !0
+      }, {
+        MIN_SAFE_INTEGER: -9007199254740991
+      });
+    }, function (t, e, r) {
+      t.exports = r(381);
+    }, function (t, e, r) {
+      t.exports = r(382);
+    }, function (t, e, r) {
+      r(383), t.exports = 9007199254740991;
+    }, function (t, e, r) {
+      r(0)({
+        target: "Number",
+        stat: !0
+      }, {
+        MAX_SAFE_INTEGER: 9007199254740991
+      });
+    }, function (t, e, r) {
+      var n = r(385),
+          i = r(153);
+
+      t.exports = function (t, e) {
+        if (i(Object(t)) || "[object Arguments]" === Object.prototype.toString.call(t)) {
+          var r = [],
+              o = !0,
+              a = !1,
+              s = void 0;
+
+          try {
+            for (var u, f = n(t); !(o = (u = f.next()).done) && (r.push(u.value), !e || r.length !== e); o = !0);
+          } catch (t) {
+            a = !0, s = t;
+          } finally {
+            try {
+              o || null == f.return || f.return();
+            } finally {
+              if (a) throw s;
+            }
+          }
+
+          return r;
+        }
+      };
+    }, function (t, e, r) {
+      t.exports = r(386);
+    }, function (t, e, r) {
+      r(41), r(46), t.exports = r(142);
+    }, function (t, e, r) {
+      t.exports = r(388);
+    }, function (t, e, r) {
+      t.exports = r(143);
+    }, function (t, e, r) {
+
+      var n = r(1),
+          i = n(r(98)),
+          o = n(r(16)),
+          a = n(r(99)),
+          s = n(r(7)),
+          u = n(r(10)),
+          f = n(r(59)),
+          c = r(100);
+      var l = {
+        a: 0,
+        A: 0,
+        c: 1,
+        C: 1,
+        g: 2,
+        G: 2,
+        t: 3,
+        T: 3,
+        n: 4,
+        N: 4
+      };
+
+      var h = function () {
+        function t() {
+          (0, s.default)(this, t), this.tags = {};
+        }
+
+        return (0, u.default)(t, [{
+          key: "isPaired",
+          value: function () {
+            return !!((0, a.default)(this) & c.BAM_FPAIRED);
+          }
+        }, {
+          key: "isProperlyPaired",
+          value: function () {
+            return !!((0, a.default)(this) & c.BAM_FPROPER_PAIR);
+          }
+        }, {
+          key: "isSegmentUnmapped",
+          value: function () {
+            return !!((0, a.default)(this) & c.BAM_FUNMAP);
+          }
+        }, {
+          key: "isMateUnmapped",
+          value: function () {
+            return !!((0, a.default)(this) & c.BAM_FMUNMAP);
+          }
+        }, {
+          key: "isReverseComplemented",
+          value: function () {
+            return !!((0, a.default)(this) & c.BAM_FREVERSE);
+          }
+        }, {
+          key: "isMateReverseComplemented",
+          value: function () {
+            return !!((0, a.default)(this) & c.BAM_FMREVERSE);
+          }
+        }, {
+          key: "isRead1",
+          value: function () {
+            return !!((0, a.default)(this) & c.BAM_FREAD1);
+          }
+        }, {
+          key: "isRead2",
+          value: function () {
+            return !!((0, a.default)(this) & c.BAM_FREAD2);
+          }
+        }, {
+          key: "isSecondary",
+          value: function () {
+            return !!((0, a.default)(this) & c.BAM_FSECONDARY);
+          }
+        }, {
+          key: "isFailedQc",
+          value: function () {
+            return !!((0, a.default)(this) & c.BAM_FQCFAIL);
+          }
+        }, {
+          key: "isDuplicate",
+          value: function () {
+            return !!((0, a.default)(this) & c.BAM_FDUP);
+          }
+        }, {
+          key: "isSupplementary",
+          value: function () {
+            return !!((0, a.default)(this) & c.BAM_FSUPPLEMENTARY);
+          }
+        }, {
+          key: "isDetached",
+          value: function () {
+            return !!(this.cramFlags & c.CRAM_FLAG_DETACHED);
+          }
+        }, {
+          key: "hasMateDownStream",
+          value: function () {
+            return !!(this.cramFlags & c.CRAM_FLAG_MATE_DOWNSTREAM);
+          }
+        }, {
+          key: "isPreservingQualityScores",
+          value: function () {
+            return !!(this.cramFlags & c.CRAM_FLAG_PRESERVE_QUAL_SCORES);
+          }
+        }, {
+          key: "isUnknownBases",
+          value: function () {
+            return !!(this.cramFlags & c.CRAM_FLAG_NO_SEQ);
+          }
+        }, {
+          key: "getReadBases",
+          value: function () {
+            return !this.readBases && this._refRegion && (this.readBases = function (t, e) {
+              if ((t.lengthOnRef || t.readLength) && !t.isUnknownBases()) {
+                var r = t.alignmentStart - e.start;
+                if (!t.readFeatures) return e.seq.substr(r, t.lengthOnRef).toUpperCase();
+
+                for (var n = "", i = r, o = 0; n.length < t.readLength;) if (o < t.readFeatures.length) {
+                  var a = t.readFeatures[o];
+                  if ("Q" === a.code || "q" === a.code) o += 1;else if (a.pos === n.length + 1) {
+                    if (o += 1, "b" === a.code) {
+                      var s = a.data.split(","),
+                          u = String.fromCharCode.apply(String, (0, f.default)(s));
+                      n += u, i += u.length;
+                    } else "B" === a.code ? (n += a.data[0], i += 1) : "X" === a.code ? (n += a.sub, i += 1) : "I" === a.code ? n += a.data : "D" === a.code ? i += a.data : "i" === a.code ? n += a.data : "N" === a.code ? i += a.data : "S" === a.code ? n += a.data : "P" === a.code || a.code;
+                  } else if (o < t.readFeatures.length) {
+                    var c = e.seq.substr(i, t.readFeatures[o].pos - n.length - 1);
+                    n += c, i += c.length;
+                  }
+                } else {
+                  var l = e.seq.substr(i, t.readLength - n.length);
+                  n += l, i += l.length;
+                }
+
+                return n.toUpperCase();
+              }
+            }(this, this._refRegion)), this.readBases;
+          }
+        }, {
+          key: "getPairOrientation",
+          value: function () {
+            if (!this.isSegmentUnmapped() && this.isPaired() && !this.isMateUnmapped() && this.mate && this.sequenceId === this.mate.sequenceId) {
+              var t = this.isReverseComplemented() ? "R" : "F",
+                  e = this.isMateReverseComplemented() ? "R" : "F",
+                  r = " ",
+                  n = " ";
+              this.isRead1() ? (r = "1", n = "2") : this.isRead2() && (r = "2", n = "1");
+              var i = [],
+                  o = this.templateLength || this.templateSize;
+              return this.alignmentStart > this.mate.alignmentStart && o > 0 && (o = -o), o > 0 ? (i[0] = t, i[1] = r, i[2] = e, i[3] = n) : (i[2] = t, i[3] = r, i[0] = e, i[1] = n), i.join("");
+            }
+
+            return null;
+          }
+        }, {
+          key: "addReferenceSequence",
+          value: function (t, e) {
+            var r;
+            this.readFeatures && (0, o.default)(r = this.readFeatures).call(r, function (r) {
+              "X" === r.code && function (t, e, r, n) {
+                if (e) {
+                  var i = n.refPos - e.start,
+                      o = e.seq.charAt(i);
+                  o && (n.ref = o);
+                  var a = l[o];
+                  void 0 === a && (a = 4);
+                  var s = r.substitutionMatrix[a][n.data];
+                  s && (n.sub = s);
+                }
+              }(0, t, e, r);
+            });
+            !this.readBases && t.start <= this.alignmentStart && t.end >= this.alignmentStart + (this.lengthOnRef || this.readLength) - 1 && (this._refRegion = t);
+          }
+        }, {
+          key: "toJSON",
+          value: function () {
+            var t,
+                e = this,
+                r = {};
+            return (0, o.default)(t = (0, i.default)(this)).call(t, function (t) {
+              "_" !== t.charAt(0) && (r[t] = e[t]);
+            }), r.readBases = this.getReadBases(), r;
+          }
+        }]), t;
+      }();
+
+      t.exports = h;
+    }, function (t, e, r) {
+
+      var n = r(1),
+          i = n(r(98)),
+          o = n(r(16)),
+          a = n(r(75)),
+          s = n(r(7)),
+          u = n(r(10)),
+          f = r(9).CramMalformedError,
+          c = r(391).instantiateCodec,
+          l = {
+        BF: "int",
+        CF: "int",
+        RI: "int",
+        RL: "int",
+        AP: "int",
+        RG: "int",
+        MF: "int",
+        NS: "int",
+        NP: "int",
+        TS: "int",
+        NF: "int",
+        TC: "byte",
+        TN: "int",
+        FN: "int",
+        FC: "byte",
+        FP: "int",
+        BS: "byte",
+        IN: "byteArray",
+        SC: "byteArray",
+        DL: "int",
+        BA: "byte",
+        BB: "byteArray",
+        RS: "int",
+        PD: "int",
+        HC: "int",
+        MQ: "int",
+        RN: "byteArray",
+        QS: "byte",
+        QQ: "byteArray",
+        TL: "int",
+        TM: "ignore",
+        TV: "ignore"
+      };
+
+      var h = function () {
+        function t(e) {
+          (0, s.default)(this, t), (0, a.default)(this, e), this.readNamesIncluded = e.preservation.RN, this.APdelta = e.preservation.AP, this.referenceRequired = !!e.preservation.RR, this.tagIdsDictionary = e.preservation.TD, this.substitutionMatrix = function (t) {
+            for (var e = new Array(5), r = 0; r < 5; r += 1) e[r] = new Array(4);
+
+            return e[0][t[0] >> 6 & 3] = "C", e[0][t[0] >> 4 & 3] = "G", e[0][t[0] >> 2 & 3] = "T", e[0][t[0] >> 0 & 3] = "N", e[1][t[1] >> 6 & 3] = "A", e[1][t[1] >> 4 & 3] = "G", e[1][t[1] >> 2 & 3] = "T", e[1][t[1] >> 0 & 3] = "N", e[2][t[2] >> 6 & 3] = "A", e[2][t[2] >> 4 & 3] = "C", e[2][t[2] >> 2 & 3] = "T", e[2][t[2] >> 0 & 3] = "N", e[3][t[3] >> 6 & 3] = "A", e[3][t[3] >> 4 & 3] = "C", e[3][t[3] >> 2 & 3] = "G", e[3][t[3] >> 0 & 3] = "N", e[4][t[4] >> 6 & 3] = "A", e[4][t[4] >> 4 & 3] = "C", e[4][t[4] >> 2 & 3] = "G", e[4][t[4] >> 0 & 3] = "T", e;
+          }(e.preservation.SM), this.dataSeriesCodecCache = {}, this.tagCodecCache = {};
+        }
+
+        return (0, u.default)(t, [{
+          key: "getCodecForTag",
+          value: function (t) {
+            if (!this.tagCodecCache[t]) {
+              var e = this.tagEncoding[t];
+              e && (this.tagCodecCache[t] = c(e, "byteArray"));
+            }
+
+            return this.tagCodecCache[t];
+          }
+        }, {
+          key: "getTagNames",
+          value: function (t) {
+            return this.tagIdsDictionary[t];
+          }
+        }, {
+          key: "getCodecForDataSeries",
+          value: function (t) {
+            if (!this.dataSeriesCodecCache[t]) {
+              var e = this.dataSeriesEncoding[t];
+
+              if (e) {
+                var r = l[t];
+                if (!r) throw new f("data series name ".concat(t, " not defined in file compression header"));
+                this.dataSeriesCodecCache[t] = c(e, r);
+              }
+            }
+
+            return this.dataSeriesCodecCache[t];
+          }
+        }, {
+          key: "toJSON",
+          value: function () {
+            var t,
+                e = this,
+                r = {};
+            return (0, o.default)(t = (0, i.default)(this)).call(t, function (t) {
+              /Cache$/.test(t) || (r[t] = e[t]);
+            }), r;
+          }
+        }]), t;
+      }();
+
+      t.exports = h;
+    }, function (t, e, r) {
+
+      var n = r(9).CramUnimplementedError,
+          i = r(392),
+          o = r(413),
+          a = r(414),
+          s = r(415),
+          u = r(416),
+          f = r(417),
+          c = {
+        1: o,
+        3: i,
+        4: s,
+        5: a,
+        6: u,
+        7: r(418),
+        9: f
+      };
+
+      function l(t) {
+        return c[t];
+      }
+
+      t.exports = {
+        getCodecClassWithId: l,
+        instantiateCodec: function t(e, r) {
+          var i = l("ignore" === r ? 0 : e.codecId);
+          if (!i) throw new n("no codec implemented for codec ID ".concat(e.codecId));
+          return new i(e.parameters, r, t);
+        }
+      };
+    }, function (t, e, r) {
+
+      var n = r(1),
+          i = n(r(97)),
+          o = n(r(59)),
+          a = n(r(77)),
+          s = n(r(148)),
+          u = n(r(159)),
+          f = n(r(48)),
+          c = n(r(102)),
+          l = n(r(16)),
+          h = n(r(103)),
+          d = n(r(403)),
+          p = n(r(7)),
+          g = n(r(10)),
+          v = n(r(32)),
+          y = n(r(27)),
+          m = n(r(33)),
+          b = r(9).CramMalformedError;
+
+      var _ = function (t) {
+        function e() {
+          var t,
+              r,
+              n = arguments.length > 0 && void 0 !== arguments[0] ? arguments[0] : {},
+              i = arguments.length > 1 ? arguments[1] : void 0;
+          if ((0, p.default)(this, e), r = (0, v.default)(this, (0, y.default)(e).call(this, n, i)), !(0, d.default)(t = ["byte", "int"]).call(t, r.dataType)) throw new TypeError("".concat(r.dataType, " decoding not yet implemented by HUFFMAN_INT codec"));
+          return r.buildCodeBook(), r.buildCodes(), r.buildCaches(), 0 === r.sortedCodes[0].bitLength && (r._decode = r._decodeZeroLengthCode), r;
+        }
+
+        return (0, m.default)(e, t), (0, g.default)(e, [{
+          key: "buildCodeBook",
+          value: function () {
+            for (var t = this, e = new Array(this.parameters.numCodes), r = 0; r < this.parameters.numCodes; r += 1) e[r] = {
+              symbol: this.parameters.symbols[r],
+              bitLength: this.parameters.bitLengths[r]
+            };
+
+            e = (0, h.default)(e).call(e, function (t, e) {
+              return t.bitLength - e.bitLength || t.symbol - e.symbol;
+            }), this.codeBook = {}, (0, l.default)(e).call(e, function (e) {
+              t.codeBook[e.bitLength] || (t.codeBook[e.bitLength] = []), t.codeBook[e.bitLength].push(e.symbol);
+            });
+          }
+        }, {
+          key: "buildCodes",
+          value: function () {
+            var t,
+                e = this;
+            this.codes = {};
+            var r = 0,
+                n = -1;
+            (0, l.default)(t = (0, c.default)(this.codeBook)).call(t, function (t) {
+              var i = (0, f.default)(t, 2),
+                  o = i[0],
+                  a = i[1];
+              o = (0, u.default)(o, 10), (0, l.default)(a).call(a, function (t) {
+                var i = {
+                  bitLength: o,
+                  value: t
+                };
+                n += 1;
+                var a,
+                    s,
+                    u = o - r;
+                if (n <<= u, i.bitCode = n, r += u, 16843009 * ((s = (858993459 & (s = (a = n) - (a >> 1) & 1431655765)) + (s >> 2 & 858993459)) + (s >> 4) & 252645135) >> 24 > o) throw new b("Symbol out of range");
+                e.codes[t] = i;
+              });
+            });
+          }
+        }, {
+          key: "buildCaches",
+          value: function () {
+            var t, e, r, n, u, f;
+            this.sortedCodes = (0, h.default)(t = (0, s.default)(this.codes)).call(t, function (t, e) {
+              return t.bitLength - e.bitLength || t.bitCode - e.bitCode;
+            }), this.sortedByValue = (0, h.default)(e = (0, s.default)(this.codes)).call(e, function (t, e) {
+              return t.value - e.value;
+            }), this.sortedValuesByBitCode = (0, a.default)(r = this.sortedCodes).call(r, function (t) {
+              return t.value;
+            }), this.sortedBitCodes = (0, a.default)(n = this.sortedCodes).call(n, function (t) {
+              return t.bitCode;
+            }), this.sortedBitLengthsByBitCode = (0, a.default)(u = this.sortedCodes).call(u, function (t) {
+              return t.bitLength;
+            });
+            var c = Math.max.apply(Math, (0, o.default)(this.sortedBitCodes));
+            this.bitCodeToValue = (0, i.default)(f = new Array(c + 1)).call(f, -1);
+
+            for (var l = 0; l < this.sortedBitCodes.length; l += 1) this.bitCodeToValue[this.sortedCodes[l].bitCode] = l;
+          }
+        }, {
+          key: "decode",
+          value: function (t, e, r, n) {
+            return this._decode(t, e, n.coreBlock);
+          }
+        }, {
+          key: "_decodeZeroLengthCode",
+          value: function () {
+            return this.sortedCodes[0].value;
+          }
+        }, {
+          key: "_decode",
+          value: function (t, e, r) {
+            for (var n = e.content, i = 0, o = 0, a = 0; a < this.sortedCodes.length; a += 1) {
+              var s = this.sortedCodes[a].bitLength;
+              o <<= s - i, o |= this._getBits(n, r, s - i), i = s;
+              var u = this.bitCodeToValue[o];
+              if (u > -1 && this.sortedBitLengthsByBitCode[u] === s) return this.sortedValuesByBitCode[u];
+
+              for (var f = a; this.sortedCodes[f + 1].bitLength === s && f < this.sortedCodes.length; f += 1) a += 1;
+            }
+
+            throw new b("Huffman symbol not found.");
+          }
+        }]), e;
+      }(r(40));
+
+      t.exports = _;
+    }, function (t, e, r) {
+      t.exports = r(394);
+    }, function (t, e, r) {
+      r(395);
+      var n = r(3);
+      t.exports = n.parseInt;
+    }, function (t, e, r) {
+      var n = r(0),
+          i = r(155);
+      n({
+        global: !0,
+        forced: parseInt != i
+      }, {
+        parseInt: i
+      });
+    }, function (t, e, r) {
+      t.exports = r(397);
+    }, function (t, e, r) {
+      r(398);
+      var n = r(3);
+      t.exports = n.Object.entries;
+    }, function (t, e, r) {
+      var n = r(0),
+          i = r(149).entries;
+      n({
+        target: "Object",
+        stat: !0
+      }, {
+        entries: function (t) {
+          return i(t);
+        }
+      });
+    }, function (t, e, r) {
+      t.exports = r(400);
+    }, function (t, e, r) {
+      var n = r(401),
+          i = Array.prototype;
+
+      t.exports = function (t) {
+        var e = t.sort;
+        return t === i || t instanceof Array && e === i.sort ? n : e;
+      };
+    }, function (t, e, r) {
+      r(402);
+      var n = r(18);
+      t.exports = n("Array").sort;
+    }, function (t, e, r) {
+
+      var n = r(0),
+          i = r(5),
+          o = r(22),
+          a = r(12),
+          s = r(54),
+          u = [].sort,
+          f = [1, 2, 3],
+          c = a(function () {
+        f.sort(void 0);
+      }),
+          l = a(function () {
+        f.sort(null);
+      }),
+          h = s("sort");
+      n({
+        target: "Array",
+        proto: !0,
+        forced: c || !l || h
+      }, {
+        sort: function (t) {
+          return void 0 === t ? u.call(o(this)) : u.call(o(this), i(t));
+        }
+      });
+    }, function (t, e, r) {
+      t.exports = r(404);
+    }, function (t, e, r) {
+      t.exports = r(405);
+    }, function (t, e, r) {
+      var n = r(406),
+          i = r(408),
+          o = Array.prototype,
+          a = String.prototype;
+
+      t.exports = function (t) {
+        var e = t.includes;
+        return t === o || t instanceof Array && e === o.includes ? n : "string" == typeof t || t === a || t instanceof String && e === a.includes ? i : e;
+      };
+    }, function (t, e, r) {
+      r(407);
+      var n = r(18);
+      t.exports = n("Array").includes;
+    }, function (t, e, r) {
+
+      var n = r(0),
+          i = r(82).includes,
+          o = r(78);
+      n({
+        target: "Array",
+        proto: !0
+      }, {
+        includes: function (t) {
+          return i(this, t, arguments.length > 1 ? arguments[1] : void 0);
+        }
+      }), o("includes");
+    }, function (t, e, r) {
+      r(409);
+      var n = r(18);
+      t.exports = n("String").includes;
+    }, function (t, e, r) {
+
+      var n = r(0),
+          i = r(410),
+          o = r(49);
+      n({
+        target: "String",
+        proto: !0,
+        forced: !r(412)("includes")
+      }, {
+        includes: function (t) {
+          return !!~String(o(this)).indexOf(i(t), arguments.length > 1 ? arguments[1] : void 0);
+        }
+      });
+    }, function (t, e, r) {
+      var n = r(411);
+
+      t.exports = function (t) {
+        if (n(t)) throw TypeError("The method doesn't accept regular expressions");
+        return t;
+      };
+    }, function (t, e, r) {
+      var n = r(14),
+          i = r(34),
+          o = r(6)("match");
+
+      t.exports = function (t) {
+        var e;
+        return n(t) && (void 0 !== (e = t[o]) ? !!e : "RegExp" == i(t));
+      };
+    }, function (t, e, r) {
+      var n = r(6)("match");
+
+      t.exports = function (t) {
+        var e = /./;
+
+        try {
+          "/./"[t](e);
+        } catch (r) {
+          try {
+            return e[n] = !1, "/./"[t](e);
+          } catch (t) {}
+        }
+
+        return !1;
+      };
+    }, function (t, e, r) {
+
+      var n = r(1),
+          i = n(r(48)),
+          o = n(r(7)),
+          a = n(r(10)),
+          s = n(r(32)),
+          u = n(r(27)),
+          f = n(r(33)),
+          c = r(9),
+          l = c.CramUnimplementedError,
+          h = c.CramMalformedError,
+          d = c.CramBufferOverrunError,
+          p = r(40),
+          g = r(58).parseItf8,
+          v = function (t) {
+        function e() {
+          var t,
+              r = arguments.length > 0 && void 0 !== arguments[0] ? arguments[0] : {},
+              n = arguments.length > 1 ? arguments[1] : void 0;
+          if ((0, o.default)(this, e), "int" === (t = (0, s.default)(this, (0, u.default)(e).call(this, r, n))).dataType) t._decodeData = t._decodeInt;else {
+            if ("byte" !== t.dataType) throw new l("".concat(t.dataType, " decoding not yet implemented by EXTERNAL codec"));
+            t._decodeData = t._decodeByte;
+          }
+          return t;
+        }
+
+        return (0, f.default)(e, t), (0, a.default)(e, [{
+          key: "decode",
+          value: function (t, e, r, n) {
+            var i = this.parameters.blockContentId,
+                o = r[i];
+            if (!o) throw new h("no block found with content ID ".concat(i));
+            var a = n.externalBlocks.getCursor(i);
+            return this._decodeData(o, a);
+          }
+        }, {
+          key: "_decodeInt",
+          value: function (t, e) {
+            var r = g(t.content, e.bytePosition),
+                n = (0, i.default)(r, 2),
+                o = n[0],
+                a = n[1];
+            return e.bytePosition += a, o;
+          }
+        }, {
+          key: "_decodeByte",
+          value: function (t, e) {
+            if (e.bytePosition >= t.content.length) throw new d("attempted to read beyond end of block. this file seems truncated.");
+            var r = t.content[e.bytePosition];
+            return e.bytePosition += 1, r;
+          }
+        }]), e;
+      }(p);
+
+      t.exports = v;
+    }, function (t, e, r) {
+
+      var n = r(1),
+          i = n(r(101)),
+          o = n(r(7)),
+          a = n(r(10)),
+          s = n(r(32)),
+          u = n(r(27)),
+          f = n(r(33)),
+          c = r(9),
+          l = c.CramBufferOverrunError,
+          h = c.CramMalformedError,
+          d = function (t) {
+        function e() {
+          var t,
+              r = arguments.length > 0 && void 0 !== arguments[0] ? arguments[0] : {},
+              n = arguments.length > 1 ? arguments[1] : void 0;
+          if ((0, o.default)(this, e), t = (0, s.default)(this, (0, u.default)(e).call(this, r, n)), "byteArray" !== n) throw new TypeError("byteArrayStop codec does not support data type ".concat(n));
+          return t._decode = t._decodeByteArray, t;
+        }
+
+        return (0, f.default)(e, t), (0, a.default)(e, [{
+          key: "decode",
+          value: function (t, e, r, n) {
+            var i = this.parameters.blockContentId,
+                o = r[i];
+            if (!o) throw new h("no block found with content ID ".concat(i));
+            var a = n.externalBlocks.getCursor(i);
+            return this._decode(o, a);
+          }
+        }, {
+          key: "_decodeByteArray",
+          value: function (t, e) {
+            for (var r = t.content, n = this.parameters.stopByte, o = e.bytePosition, a = e.bytePosition; r[a] !== n && a < r.length;) {
+              if (a === r.length) throw new l("byteArrayStop reading beyond length of data buffer?");
+              a += 1;
+            }
+
+            return e.bytePosition = a + 1, (0, i.default)(r).call(r, o, a);
+          }
+        }]), e;
+      }(r(40));
+
+      t.exports = d;
+    }, function (t, e, r) {
+
+      var n,
+          i = r(1),
+          o = i(r(16)),
+          a = i(r(7)),
+          s = i(r(10)),
+          u = i(r(32)),
+          f = i(r(27)),
+          c = i(r(33)),
+          l = r(58).tinyMemoize,
+          h = function (t) {
+        function e() {
+          var t,
+              r = arguments.length > 0 && void 0 !== arguments[0] ? arguments[0] : {},
+              n = arguments.length > 1 ? arguments[1] : void 0,
+              i = arguments.length > 2 ? arguments[2] : void 0;
+          if ((0, a.default)(this, e), (t = (0, u.default)(this, (0, f.default)(e).call(this, r, n))).instantiateCodec = i, "byteArray" !== n) throw new TypeError("byteArrayLength does not support data type ".concat(n));
+          return t;
+        }
+
+        return (0, c.default)(e, t), (0, s.default)(e, [{
+          key: "decode",
+          value: function (t, e, r, n) {
+            for (var i = this._getLengthCodec().decode(t, e, r, n), o = this._getDataCodec(), a = new Array(i), s = 0; s < i; s += 1) a[s] = o.decode(t, e, r, n);
+
+            return a;
+          }
+        }, {
+          key: "_getLengthCodec",
+          value: function () {
+            var t = this.parameters.lengthsEncoding;
+            return this.instantiateCodec(t, "int");
+          }
+        }, {
+          key: "_getDataCodec",
+          value: function () {
+            var t = this.parameters.valuesEncoding;
+            return this.instantiateCodec(t, "byte");
+          }
+        }]), e;
+      }(r(40));
+
+      (0, o.default)(n = "_getLengthCodec _getDataCodec".split(" ")).call(n, function (t) {
+        return l(h, t);
+      }), t.exports = h;
+    }, function (t, e, r) {
+
+      var n = r(1),
+          i = n(r(7)),
+          o = n(r(10)),
+          a = n(r(32)),
+          s = n(r(27)),
+          u = n(r(33)),
+          f = r(9).CramUnimplementedError,
+          c = function (t) {
+        function e() {
+          var t,
+              r = arguments.length > 0 && void 0 !== arguments[0] ? arguments[0] : {},
+              n = arguments.length > 1 ? arguments[1] : void 0;
+          if ((0, i.default)(this, e), "int" !== (t = (0, a.default)(this, (0, s.default)(e).call(this, r, n))).dataType) throw new f("".concat(t.dataType, " decoding not yet implemented by BETA codec"));
+          return t;
+        }
+
+        return (0, u.default)(e, t), (0, o.default)(e, [{
+          key: "decode",
+          value: function (t, e, r, n) {
+            return this._getBits(e.content, n.coreBlock, this.parameters.length) - this.parameters.offset;
+          }
+        }]), e;
+      }(r(40));
+
+      t.exports = c;
+    }, function (t, e, r) {
+
+      var n = r(1),
+          i = n(r(7)),
+          o = n(r(10)),
+          a = n(r(32)),
+          s = n(r(27)),
+          u = n(r(33)),
+          f = r(9).CramUnimplementedError,
+          c = function (t) {
+        function e() {
+          var t,
+              r = arguments.length > 0 && void 0 !== arguments[0] ? arguments[0] : {},
+              n = arguments.length > 1 ? arguments[1] : void 0;
+          if ((0, i.default)(this, e), "int" !== (t = (0, a.default)(this, (0, s.default)(e).call(this, r, n))).dataType) throw new f("".concat(t.dataType, " decoding not yet implemented by GAMMA codec"));
+          return t;
+        }
+
+        return (0, u.default)(e, t), (0, o.default)(e, [{
+          key: "decode",
+          value: function (t, e, r, n) {
+            for (var i = 1; 0 === this._getBits(e.content, n.coreBlock, 1);) i += 1;
+
+            return (this._getBits(e.content, n.coreBlock, i - 1) | 1 << i - 1) - this.parameters.offset;
+          }
+        }]), e;
+      }(r(40));
+
+      t.exports = c;
+    }, function (t, e, r) {
+
+      var n = r(1),
+          i = n(r(7)),
+          o = n(r(10)),
+          a = n(r(32)),
+          s = n(r(27)),
+          u = n(r(33)),
+          f = r(9).CramUnimplementedError,
+          c = function (t) {
+        function e() {
+          var t,
+              r = arguments.length > 0 && void 0 !== arguments[0] ? arguments[0] : {},
+              n = arguments.length > 1 ? arguments[1] : void 0;
+          if ((0, i.default)(this, e), "int" !== (t = (0, a.default)(this, (0, s.default)(e).call(this, r, n))).dataType) throw new f("".concat(t.dataType, " decoding not yet implemented by SUBEXP codec"));
+          return t;
+        }
+
+        return (0, u.default)(e, t), (0, o.default)(e, [{
+          key: "decode",
+          value: function (t, e, r, n) {
+            for (var i, o, a = 0; this._getBits(e.content, n.coreBlock, 1);) a += 1;
+
+            return 0 === a ? (i = this.parameters.K, o = this._getBits(e.content, n.coreBlock, i)) : o = 1 << (i = a + this.parameters.K - 1) | this._getBits(e.content, n.coreBlock, i), o - this.parameters.offset;
+          }
+        }]), e;
+      }(r(40));
+
+      t.exports = c;
+    }, function (t, e, r) {
+
+      var n = r(420),
+          i = r(422);
+
+      function o() {
+        this.protocol = null, this.slashes = null, this.auth = null, this.host = null, this.port = null, this.hostname = null, this.hash = null, this.search = null, this.query = null, this.pathname = null, this.path = null, this.href = null;
+      }
+
+      e.parse = b, e.resolve = function (t, e) {
+        return b(t, !1, !0).resolve(e);
+      }, e.resolveObject = function (t, e) {
+        return t ? b(t, !1, !0).resolveObject(e) : e;
+      }, e.format = function (t) {
+        i.isString(t) && (t = b(t));
+        return t instanceof o ? t.format() : o.prototype.format.call(t);
+      }, e.Url = o;
+      var a = /^([a-z0-9.+-]+:)/i,
+          s = /:[0-9]*$/,
+          u = /^(\/\/?(?!\/)[^\?\s]*)(\?[^\s]*)?$/,
+          f = ["{", "}", "|", "\\", "^", "`"].concat(["<", ">", '"', "`", " ", "\r", "\n", "\t"]),
+          c = ["'"].concat(f),
+          l = ["%", "/", "?", ";", "#"].concat(c),
+          h = ["/", "?", "#"],
+          d = /^[+a-z0-9A-Z_-]{0,63}$/,
+          p = /^([+a-z0-9A-Z_-]{0,63})(.*)$/,
+          g = {
+        javascript: !0,
+        "javascript:": !0
+      },
+          v = {
+        javascript: !0,
+        "javascript:": !0
+      },
+          y = {
+        http: !0,
+        https: !0,
+        ftp: !0,
+        gopher: !0,
+        file: !0,
+        "http:": !0,
+        "https:": !0,
+        "ftp:": !0,
+        "gopher:": !0,
+        "file:": !0
+      },
+          m = r(423);
+
+      function b(t, e, r) {
+        if (t && i.isObject(t) && t instanceof o) return t;
+        var n = new o();
+        return n.parse(t, e, r), n;
+      }
+
+      o.prototype.parse = function (t, e, r) {
+        if (!i.isString(t)) throw new TypeError("Parameter 'url' must be a string, not " + typeof t);
+        var o = t.indexOf("?"),
+            s = -1 !== o && o < t.indexOf("#") ? "?" : "#",
+            f = t.split(s);
+        f[0] = f[0].replace(/\\/g, "/");
+        var b = t = f.join(s);
+
+        if (b = b.trim(), !r && 1 === t.split("#").length) {
+          var _ = u.exec(b);
+
+          if (_) return this.path = b, this.href = b, this.pathname = _[1], _[2] ? (this.search = _[2], this.query = e ? m.parse(this.search.substr(1)) : this.search.substr(1)) : e && (this.search = "", this.query = {}), this;
+        }
+
+        var w = a.exec(b);
+
+        if (w) {
+          var x = (w = w[0]).toLowerCase();
+          this.protocol = x, b = b.substr(w.length);
+        }
+
+        if (r || w || b.match(/^\/\/[^@\/]+@[^@\/]+/)) {
+          var E = "//" === b.substr(0, 2);
+          !E || w && v[w] || (b = b.substr(2), this.slashes = !0);
+        }
+
+        if (!v[w] && (E || w && !y[w])) {
+          for (var S, k, A = -1, C = 0; C < h.length; C++) {
+            -1 !== (T = b.indexOf(h[C])) && (-1 === A || T < A) && (A = T);
+          }
+
+          -1 !== (k = -1 === A ? b.lastIndexOf("@") : b.lastIndexOf("@", A)) && (S = b.slice(0, k), b = b.slice(k + 1), this.auth = decodeURIComponent(S)), A = -1;
+
+          for (C = 0; C < l.length; C++) {
+            var T;
+            -1 !== (T = b.indexOf(l[C])) && (-1 === A || T < A) && (A = T);
+          }
+
+          -1 === A && (A = b.length), this.host = b.slice(0, A), b = b.slice(A), this.parseHost(), this.hostname = this.hostname || "";
+          var R = "[" === this.hostname[0] && "]" === this.hostname[this.hostname.length - 1];
+          if (!R) for (var O = this.hostname.split(/\./), I = (C = 0, O.length); C < I; C++) {
+            var L = O[C];
+
+            if (L && !L.match(d)) {
+              for (var B = "", P = 0, F = L.length; P < F; P++) L.charCodeAt(P) > 127 ? B += "x" : B += L[P];
+
+              if (!B.match(d)) {
+                var N = O.slice(0, C),
+                    M = O.slice(C + 1),
+                    j = L.match(p);
+                j && (N.push(j[1]), M.unshift(j[2])), M.length && (b = "/" + M.join(".") + b), this.hostname = N.join(".");
+                break;
+              }
+            }
+          }
+          this.hostname.length > 255 ? this.hostname = "" : this.hostname = this.hostname.toLowerCase(), R || (this.hostname = n.toASCII(this.hostname));
+          var z = this.port ? ":" + this.port : "",
+              U = this.hostname || "";
+          this.host = U + z, this.href += this.host, R && (this.hostname = this.hostname.substr(1, this.hostname.length - 2), "/" !== b[0] && (b = "/" + b));
+        }
+
+        if (!g[x]) for (C = 0, I = c.length; C < I; C++) {
+          var D = c[C];
+
+          if (-1 !== b.indexOf(D)) {
+            var q = encodeURIComponent(D);
+            q === D && (q = escape(D)), b = b.split(D).join(q);
+          }
+        }
+        var Z = b.indexOf("#");
+        -1 !== Z && (this.hash = b.substr(Z), b = b.slice(0, Z));
+        var H = b.indexOf("?");
+
+        if (-1 !== H ? (this.search = b.substr(H), this.query = b.substr(H + 1), e && (this.query = m.parse(this.query)), b = b.slice(0, H)) : e && (this.search = "", this.query = {}), b && (this.pathname = b), y[x] && this.hostname && !this.pathname && (this.pathname = "/"), this.pathname || this.search) {
+          z = this.pathname || "";
+          var V = this.search || "";
+          this.path = z + V;
+        }
+
+        return this.href = this.format(), this;
+      }, o.prototype.format = function () {
+        var t = this.auth || "";
+        t && (t = (t = encodeURIComponent(t)).replace(/%3A/i, ":"), t += "@");
+        var e = this.protocol || "",
+            r = this.pathname || "",
+            n = this.hash || "",
+            o = !1,
+            a = "";
+        this.host ? o = t + this.host : this.hostname && (o = t + (-1 === this.hostname.indexOf(":") ? this.hostname : "[" + this.hostname + "]"), this.port && (o += ":" + this.port)), this.query && i.isObject(this.query) && Object.keys(this.query).length && (a = m.stringify(this.query));
+        var s = this.search || a && "?" + a || "";
+        return e && ":" !== e.substr(-1) && (e += ":"), this.slashes || (!e || y[e]) && !1 !== o ? (o = "//" + (o || ""), r && "/" !== r.charAt(0) && (r = "/" + r)) : o || (o = ""), n && "#" !== n.charAt(0) && (n = "#" + n), s && "?" !== s.charAt(0) && (s = "?" + s), e + o + (r = r.replace(/[?#]/g, function (t) {
+          return encodeURIComponent(t);
+        })) + (s = s.replace("#", "%23")) + n;
+      }, o.prototype.resolve = function (t) {
+        return this.resolveObject(b(t, !1, !0)).format();
+      }, o.prototype.resolveObject = function (t) {
+        if (i.isString(t)) {
+          var e = new o();
+          e.parse(t, !1, !0), t = e;
+        }
+
+        for (var r = new o(), n = Object.keys(this), a = 0; a < n.length; a++) {
+          var s = n[a];
+          r[s] = this[s];
+        }
+
+        if (r.hash = t.hash, "" === t.href) return r.href = r.format(), r;
+
+        if (t.slashes && !t.protocol) {
+          for (var u = Object.keys(t), f = 0; f < u.length; f++) {
+            var c = u[f];
+            "protocol" !== c && (r[c] = t[c]);
+          }
+
+          return y[r.protocol] && r.hostname && !r.pathname && (r.path = r.pathname = "/"), r.href = r.format(), r;
+        }
+
+        if (t.protocol && t.protocol !== r.protocol) {
+          if (!y[t.protocol]) {
+            for (var l = Object.keys(t), h = 0; h < l.length; h++) {
+              var d = l[h];
+              r[d] = t[d];
+            }
+
+            return r.href = r.format(), r;
+          }
+
+          if (r.protocol = t.protocol, t.host || v[t.protocol]) r.pathname = t.pathname;else {
+            for (var p = (t.pathname || "").split("/"); p.length && !(t.host = p.shift()););
+
+            t.host || (t.host = ""), t.hostname || (t.hostname = ""), "" !== p[0] && p.unshift(""), p.length < 2 && p.unshift(""), r.pathname = p.join("/");
+          }
+
+          if (r.search = t.search, r.query = t.query, r.host = t.host || "", r.auth = t.auth, r.hostname = t.hostname || t.host, r.port = t.port, r.pathname || r.search) {
+            var g = r.pathname || "",
+                m = r.search || "";
+            r.path = g + m;
+          }
+
+          return r.slashes = r.slashes || t.slashes, r.href = r.format(), r;
+        }
+
+        var b = r.pathname && "/" === r.pathname.charAt(0),
+            _ = t.host || t.pathname && "/" === t.pathname.charAt(0),
+            w = _ || b || r.host && t.pathname,
+            x = w,
+            E = r.pathname && r.pathname.split("/") || [],
+            S = (p = t.pathname && t.pathname.split("/") || [], r.protocol && !y[r.protocol]);
+
+        if (S && (r.hostname = "", r.port = null, r.host && ("" === E[0] ? E[0] = r.host : E.unshift(r.host)), r.host = "", t.protocol && (t.hostname = null, t.port = null, t.host && ("" === p[0] ? p[0] = t.host : p.unshift(t.host)), t.host = null), w = w && ("" === p[0] || "" === E[0])), _) r.host = t.host || "" === t.host ? t.host : r.host, r.hostname = t.hostname || "" === t.hostname ? t.hostname : r.hostname, r.search = t.search, r.query = t.query, E = p;else if (p.length) E || (E = []), E.pop(), E = E.concat(p), r.search = t.search, r.query = t.query;else if (!i.isNullOrUndefined(t.search)) {
+          if (S) r.hostname = r.host = E.shift(), (R = !!(r.host && r.host.indexOf("@") > 0) && r.host.split("@")) && (r.auth = R.shift(), r.host = r.hostname = R.shift());
+          return r.search = t.search, r.query = t.query, i.isNull(r.pathname) && i.isNull(r.search) || (r.path = (r.pathname ? r.pathname : "") + (r.search ? r.search : "")), r.href = r.format(), r;
+        }
+        if (!E.length) return r.pathname = null, r.search ? r.path = "/" + r.search : r.path = null, r.href = r.format(), r;
+
+        for (var k = E.slice(-1)[0], A = (r.host || t.host || E.length > 1) && ("." === k || ".." === k) || "" === k, C = 0, T = E.length; T >= 0; T--) "." === (k = E[T]) ? E.splice(T, 1) : ".." === k ? (E.splice(T, 1), C++) : C && (E.splice(T, 1), C--);
+
+        if (!w && !x) for (; C--; C) E.unshift("..");
+        !w || "" === E[0] || E[0] && "/" === E[0].charAt(0) || E.unshift(""), A && "/" !== E.join("/").substr(-1) && E.push("");
+        var R,
+            O = "" === E[0] || E[0] && "/" === E[0].charAt(0);
+        S && (r.hostname = r.host = O ? "" : E.length ? E.shift() : "", (R = !!(r.host && r.host.indexOf("@") > 0) && r.host.split("@")) && (r.auth = R.shift(), r.host = r.hostname = R.shift()));
+        return (w = w || r.host && E.length) && !O && E.unshift(""), E.length ? r.pathname = E.join("/") : (r.pathname = null, r.path = null), i.isNull(r.pathname) && i.isNull(r.search) || (r.path = (r.pathname ? r.pathname : "") + (r.search ? r.search : "")), r.auth = t.auth || r.auth, r.slashes = r.slashes || t.slashes, r.href = r.format(), r;
+      }, o.prototype.parseHost = function () {
+        var t = this.host,
+            e = s.exec(t);
+        e && (":" !== (e = e[0]) && (this.port = e.substr(1)), t = t.substr(0, t.length - e.length)), t && (this.hostname = t);
+      };
+    }, function (t, e, r) {
+      (function (t, n) {
+        var i;
+        /*! https://mths.be/punycode v1.4.1 by @mathias */
+
+        !function (o) {
+          e && e.nodeType, t && t.nodeType;
+          var a = "object" == typeof n && n;
+          a.global !== a && a.window !== a && a.self;
+          var s,
+              u = 2147483647,
+              f = 36,
+              c = 1,
+              l = 26,
+              h = 38,
+              d = 700,
+              p = 72,
+              g = 128,
+              v = "-",
+              y = /^xn--/,
+              m = /[^\x20-\x7E]/,
+              b = /[\x2E\u3002\uFF0E\uFF61]/g,
+              _ = {
+            overflow: "Overflow: input needs wider integers to process",
+            "not-basic": "Illegal input >= 0x80 (not a basic code point)",
+            "invalid-input": "Invalid input"
+          },
+              w = f - c,
+              x = Math.floor,
+              E = String.fromCharCode;
+
+          function S(t) {
+            throw new RangeError(_[t]);
+          }
+
+          function k(t, e) {
+            for (var r = t.length, n = []; r--;) n[r] = e(t[r]);
+
+            return n;
+          }
+
+          function A(t, e) {
+            var r = t.split("@"),
+                n = "";
+            return r.length > 1 && (n = r[0] + "@", t = r[1]), n + k((t = t.replace(b, ".")).split("."), e).join(".");
+          }
+
+          function C(t) {
+            for (var e, r, n = [], i = 0, o = t.length; i < o;) (e = t.charCodeAt(i++)) >= 55296 && e <= 56319 && i < o ? 56320 == (64512 & (r = t.charCodeAt(i++))) ? n.push(((1023 & e) << 10) + (1023 & r) + 65536) : (n.push(e), i--) : n.push(e);
+
+            return n;
+          }
+
+          function T(t) {
+            return k(t, function (t) {
+              var e = "";
+              return t > 65535 && (e += E((t -= 65536) >>> 10 & 1023 | 55296), t = 56320 | 1023 & t), e += E(t);
+            }).join("");
+          }
+
+          function R(t, e) {
+            return t + 22 + 75 * (t < 26) - ((0 != e) << 5);
+          }
+
+          function O(t, e, r) {
+            var n = 0;
+
+            for (t = r ? x(t / d) : t >> 1, t += x(t / e); t > w * l >> 1; n += f) t = x(t / w);
+
+            return x(n + (w + 1) * t / (t + h));
+          }
+
+          function I(t) {
+            var e,
+                r,
+                n,
+                i,
+                o,
+                a,
+                s,
+                h,
+                d,
+                y,
+                m,
+                b = [],
+                _ = t.length,
+                w = 0,
+                E = g,
+                k = p;
+
+            for ((r = t.lastIndexOf(v)) < 0 && (r = 0), n = 0; n < r; ++n) t.charCodeAt(n) >= 128 && S("not-basic"), b.push(t.charCodeAt(n));
+
+            for (i = r > 0 ? r + 1 : 0; i < _;) {
+              for (o = w, a = 1, s = f; i >= _ && S("invalid-input"), ((h = (m = t.charCodeAt(i++)) - 48 < 10 ? m - 22 : m - 65 < 26 ? m - 65 : m - 97 < 26 ? m - 97 : f) >= f || h > x((u - w) / a)) && S("overflow"), w += h * a, !(h < (d = s <= k ? c : s >= k + l ? l : s - k)); s += f) a > x(u / (y = f - d)) && S("overflow"), a *= y;
+
+              k = O(w - o, e = b.length + 1, 0 == o), x(w / e) > u - E && S("overflow"), E += x(w / e), w %= e, b.splice(w++, 0, E);
+            }
+
+            return T(b);
+          }
+
+          function L(t) {
+            var e,
+                r,
+                n,
+                i,
+                o,
+                a,
+                s,
+                h,
+                d,
+                y,
+                m,
+                b,
+                _,
+                w,
+                k,
+                A = [];
+
+            for (b = (t = C(t)).length, e = g, r = 0, o = p, a = 0; a < b; ++a) (m = t[a]) < 128 && A.push(E(m));
+
+            for (n = i = A.length, i && A.push(v); n < b;) {
+              for (s = u, a = 0; a < b; ++a) (m = t[a]) >= e && m < s && (s = m);
+
+              for (s - e > x((u - r) / (_ = n + 1)) && S("overflow"), r += (s - e) * _, e = s, a = 0; a < b; ++a) if ((m = t[a]) < e && ++r > u && S("overflow"), m == e) {
+                for (h = r, d = f; !(h < (y = d <= o ? c : d >= o + l ? l : d - o)); d += f) k = h - y, w = f - y, A.push(E(R(y + k % w, 0))), h = x(k / w);
+
+                A.push(E(R(h, 0))), o = O(r, _, n == i), r = 0, ++n;
+              }
+
+              ++r, ++e;
+            }
+
+            return A.join("");
+          }
+
+          s = {
+            version: "1.4.1",
+            ucs2: {
+              decode: C,
+              encode: T
+            },
+            decode: I,
+            encode: L,
+            toASCII: function (t) {
+              return A(t, function (t) {
+                return m.test(t) ? "xn--" + L(t) : t;
+              });
+            },
+            toUnicode: function (t) {
+              return A(t, function (t) {
+                return y.test(t) ? I(t.slice(4).toLowerCase()) : t;
+              });
+            }
+          }, void 0 === (i = function () {
+            return s;
+          }.call(e, r, e, t)) || (t.exports = i);
+        }();
+      }).call(this, r(421)(t), r(23));
+    }, function (t, e) {
+      t.exports = function (t) {
+        return t.webpackPolyfill || (t.deprecate = function () {}, t.paths = [], t.children || (t.children = []), Object.defineProperty(t, "loaded", {
+          enumerable: !0,
+          get: function () {
+            return t.l;
+          }
+        }), Object.defineProperty(t, "id", {
+          enumerable: !0,
+          get: function () {
+            return t.i;
+          }
+        }), t.webpackPolyfill = 1), t;
+      };
+    }, function (t, e, r) {
+
+      t.exports = {
+        isString: function (t) {
+          return "string" == typeof t;
+        },
+        isObject: function (t) {
+          return "object" == typeof t && null !== t;
+        },
+        isNull: function (t) {
+          return null === t;
+        },
+        isNullOrUndefined: function (t) {
+          return null == t;
+        }
+      };
+    }, function (t, e, r) {
+
+      e.decode = e.parse = r(424), e.encode = e.stringify = r(425);
+    }, function (t, e, r) {
+
+      function n(t, e) {
+        return Object.prototype.hasOwnProperty.call(t, e);
+      }
+
+      t.exports = function (t, e, r, o) {
+        e = e || "&", r = r || "=";
+        var a = {};
+        if ("string" != typeof t || 0 === t.length) return a;
+        var s = /\+/g;
+        t = t.split(e);
+        var u = 1e3;
+        o && "number" == typeof o.maxKeys && (u = o.maxKeys);
+        var f = t.length;
+        u > 0 && f > u && (f = u);
+
+        for (var c = 0; c < f; ++c) {
+          var l,
+              h,
+              d,
+              p,
+              g = t[c].replace(s, "%20"),
+              v = g.indexOf(r);
+          v >= 0 ? (l = g.substr(0, v), h = g.substr(v + 1)) : (l = g, h = ""), d = decodeURIComponent(l), p = decodeURIComponent(h), n(a, d) ? i(a[d]) ? a[d].push(p) : a[d] = [a[d], p] : a[d] = p;
+        }
+
+        return a;
+      };
+
+      var i = Array.isArray || function (t) {
+        return "[object Array]" === Object.prototype.toString.call(t);
+      };
+    }, function (t, e, r) {
+
+      var n = function (t) {
+        switch (typeof t) {
+          case "string":
+            return t;
+
+          case "boolean":
+            return t ? "true" : "false";
+
+          case "number":
+            return isFinite(t) ? t : "";
+
+          default:
+            return "";
+        }
+      };
+
+      t.exports = function (t, e, r, s) {
+        return e = e || "&", r = r || "=", null === t && (t = void 0), "object" == typeof t ? o(a(t), function (a) {
+          var s = encodeURIComponent(n(a)) + r;
+          return i(t[a]) ? o(t[a], function (t) {
+            return s + encodeURIComponent(n(t));
+          }).join(e) : s + encodeURIComponent(n(t[a]));
+        }).join(e) : s ? encodeURIComponent(n(s)) + r + encodeURIComponent(n(t)) : "";
+      };
+
+      var i = Array.isArray || function (t) {
+        return "[object Array]" === Object.prototype.toString.call(t);
+      };
+
+      function o(t, e) {
+        if (t.map) return t.map(e);
+
+        for (var r = [], n = 0; n < t.length; n++) r.push(e(t[n], n));
+
+        return r;
+      }
+
+      var a = Object.keys || function (t) {
+        var e = [];
+
+        for (var r in t) Object.prototype.hasOwnProperty.call(t, r) && e.push(r);
+
+        return e;
+      };
+    }, function (t, e, r) {
+
+      (function (e) {
+        var n = r(1),
+            i = n(r(30)),
+            o = n(r(159)),
+            a = n(r(37)),
+            s = n(r(31)),
+            u = n(r(7)),
+            f = n(r(10)),
+            c = r(427),
+            l = r(428),
+            h = function () {
+          function t(e) {
+            var r = this;
+            (0, u.default)(this, t), this.position = 0, this.url = e, this.cache = new l({
+              fetch: function (t, e) {
+                return r._fetch(t, e);
+              }
+            });
+          }
+
+          var r, n, h;
+          return (0, f.default)(t, [{
+            key: "_fetch",
+            value: (h = (0, s.default)(i.default.mark(function t(r, n) {
+              var s, u, f, l, h, d;
+              return i.default.wrap(function (t) {
+                for (;;) switch (t.prev = t.next) {
+                  case 0:
+                    return u = {}, n < 1 / 0 ? u.range = (0, a.default)(f = "bytes=".concat(r, "-")).call(f, r + n) : n === 1 / 0 && 0 !== r && (u.range = "bytes=".concat(r, "-")), t.next = 4, c(this.url, {
+                      method: "GET",
+                      headers: u,
+                      redirect: "follow",
+                      mode: "cors"
+                    });
+
+                  case 4:
+                    if ((200 !== (l = t.sent).status || 0 !== r) && 206 !== l.status) {
+                      t.next = 14;
+                      break;
+                    }
+
+                    return t.t0 = e, t.next = 9, l.arrayBuffer();
+
+                  case 9:
+                    return t.t1 = t.sent, h = t.t0.from.call(t.t0, t.t1), (d = /\/(\d+)$/.exec(l.headers.get("content-range")))[1] && (this._stat = {
+                      size: (0, o.default)(d[1], 10)
+                    }), t.abrupt("return", h);
+
+                  case 14:
+                    throw new Error((0, a.default)(s = "HTTP ".concat(l.status, " fetching ")).call(s, this.url));
+
+                  case 15:
+                  case "end":
+                    return t.stop();
+                }
+              }, t, this);
+            })), function (t, e) {
+              return h.apply(this, arguments);
+            })
+          }, {
+            key: "read",
+            value: function (t) {
+              var e = arguments.length > 1 && void 0 !== arguments[1] ? arguments[1] : 0,
+                  r = arguments.length > 2 && void 0 !== arguments[2] ? arguments[2] : 1 / 0,
+                  n = arguments.length > 3 && void 0 !== arguments[3] ? arguments[3] : 0,
+                  i = n;
+              return null === i && (i = this.position, this.position += r), this.cache.get(t, e, r, n);
+            }
+          }, {
+            key: "readFile",
+            value: (n = (0, s.default)(i.default.mark(function t() {
+              var r;
+              return i.default.wrap(function (t) {
+                for (;;) switch (t.prev = t.next) {
+                  case 0:
+                    return t.next = 2, c(this.url, {
+                      method: "GET",
+                      redirect: "follow",
+                      mode: "cors"
+                    });
+
+                  case 2:
+                    return r = t.sent, t.t0 = e, t.next = 6, r.arrayBuffer();
+
+                  case 6:
+                    return t.t1 = t.sent, t.abrupt("return", t.t0.from.call(t.t0, t.t1));
+
+                  case 8:
+                  case "end":
+                    return t.stop();
+                }
+              }, t, this);
+            })), function () {
+              return n.apply(this, arguments);
+            })
+          }, {
+            key: "stat",
+            value: (r = (0, s.default)(i.default.mark(function t() {
+              var r;
+              return i.default.wrap(function (t) {
+                for (;;) switch (t.prev = t.next) {
+                  case 0:
+                    if (this._stat) {
+                      t.next = 6;
+                      break;
+                    }
+
+                    return r = e.allocUnsafe(10), t.next = 4, this.read(r, 0, 10, 0);
+
+                  case 4:
+                    if (this._stat) {
+                      t.next = 6;
+                      break;
+                    }
+
+                    throw new Error("unable to determine size of file at ".concat(this.url));
+
+                  case 6:
+                    return t.abrupt("return", this._stat);
+
+                  case 7:
+                  case "end":
+                    return t.stop();
+                }
+              }, t, this);
+            })), function () {
+              return r.apply(this, arguments);
+            })
+          }]), t;
+        }();
+
+        t.exports = h;
+      }).call(this, r(19).Buffer);
+    }, function (t, e) {
+      var r = function (t) {
+        function e() {
+          this.fetch = !1, this.DOMException = t.DOMException;
+        }
+
+        return e.prototype = t, new e();
+      }("undefined" != typeof self ? self : this);
+
+      !function (t) {
+        !function (e) {
+          var r = {
+            searchParams: "URLSearchParams" in t,
+            iterable: "Symbol" in t && "iterator" in Symbol,
+            blob: "FileReader" in t && "Blob" in t && function () {
+              try {
+                return new Blob(), !0;
+              } catch (t) {
+                return !1;
+              }
+            }(),
+            formData: "FormData" in t,
+            arrayBuffer: "ArrayBuffer" in t
+          };
+          if (r.arrayBuffer) var n = ["[object Int8Array]", "[object Uint8Array]", "[object Uint8ClampedArray]", "[object Int16Array]", "[object Uint16Array]", "[object Int32Array]", "[object Uint32Array]", "[object Float32Array]", "[object Float64Array]"],
+              i = ArrayBuffer.isView || function (t) {
+            return t && n.indexOf(Object.prototype.toString.call(t)) > -1;
+          };
+
+          function o(t) {
+            if ("string" != typeof t && (t = String(t)), /[^a-z0-9\-#$%&'*+.^_`|~]/i.test(t)) throw new TypeError("Invalid character in header field name");
+            return t.toLowerCase();
+          }
+
+          function a(t) {
+            return "string" != typeof t && (t = String(t)), t;
+          }
+
+          function s(t) {
+            var e = {
+              next: function () {
+                var e = t.shift();
+                return {
+                  done: void 0 === e,
+                  value: e
+                };
+              }
+            };
+            return r.iterable && (e[Symbol.iterator] = function () {
+              return e;
+            }), e;
+          }
+
+          function u(t) {
+            this.map = {}, t instanceof u ? t.forEach(function (t, e) {
+              this.append(e, t);
+            }, this) : Array.isArray(t) ? t.forEach(function (t) {
+              this.append(t[0], t[1]);
+            }, this) : t && Object.getOwnPropertyNames(t).forEach(function (e) {
+              this.append(e, t[e]);
+            }, this);
+          }
+
+          function f(t) {
+            if (t.bodyUsed) return Promise.reject(new TypeError("Already read"));
+            t.bodyUsed = !0;
+          }
+
+          function c(t) {
+            return new Promise(function (e, r) {
+              t.onload = function () {
+                e(t.result);
+              }, t.onerror = function () {
+                r(t.error);
+              };
+            });
+          }
+
+          function l(t) {
+            var e = new FileReader(),
+                r = c(e);
+            return e.readAsArrayBuffer(t), r;
+          }
+
+          function h(t) {
+            if (t.slice) return t.slice(0);
+            var e = new Uint8Array(t.byteLength);
+            return e.set(new Uint8Array(t)), e.buffer;
+          }
+
+          function d() {
+            return this.bodyUsed = !1, this._initBody = function (t) {
+              var e;
+              this._bodyInit = t, t ? "string" == typeof t ? this._bodyText = t : r.blob && Blob.prototype.isPrototypeOf(t) ? this._bodyBlob = t : r.formData && FormData.prototype.isPrototypeOf(t) ? this._bodyFormData = t : r.searchParams && URLSearchParams.prototype.isPrototypeOf(t) ? this._bodyText = t.toString() : r.arrayBuffer && r.blob && (e = t) && DataView.prototype.isPrototypeOf(e) ? (this._bodyArrayBuffer = h(t.buffer), this._bodyInit = new Blob([this._bodyArrayBuffer])) : r.arrayBuffer && (ArrayBuffer.prototype.isPrototypeOf(t) || i(t)) ? this._bodyArrayBuffer = h(t) : this._bodyText = t = Object.prototype.toString.call(t) : this._bodyText = "", this.headers.get("content-type") || ("string" == typeof t ? this.headers.set("content-type", "text/plain;charset=UTF-8") : this._bodyBlob && this._bodyBlob.type ? this.headers.set("content-type", this._bodyBlob.type) : r.searchParams && URLSearchParams.prototype.isPrototypeOf(t) && this.headers.set("content-type", "application/x-www-form-urlencoded;charset=UTF-8"));
+            }, r.blob && (this.blob = function () {
+              var t = f(this);
+              if (t) return t;
+              if (this._bodyBlob) return Promise.resolve(this._bodyBlob);
+              if (this._bodyArrayBuffer) return Promise.resolve(new Blob([this._bodyArrayBuffer]));
+              if (this._bodyFormData) throw new Error("could not read FormData body as blob");
+              return Promise.resolve(new Blob([this._bodyText]));
+            }, this.arrayBuffer = function () {
+              return this._bodyArrayBuffer ? f(this) || Promise.resolve(this._bodyArrayBuffer) : this.blob().then(l);
+            }), this.text = function () {
+              var t,
+                  e,
+                  r,
+                  n = f(this);
+              if (n) return n;
+              if (this._bodyBlob) return t = this._bodyBlob, e = new FileReader(), r = c(e), e.readAsText(t), r;
+              if (this._bodyArrayBuffer) return Promise.resolve(function (t) {
+                for (var e = new Uint8Array(t), r = new Array(e.length), n = 0; n < e.length; n++) r[n] = String.fromCharCode(e[n]);
+
+                return r.join("");
+              }(this._bodyArrayBuffer));
+              if (this._bodyFormData) throw new Error("could not read FormData body as text");
+              return Promise.resolve(this._bodyText);
+            }, r.formData && (this.formData = function () {
+              return this.text().then(v);
+            }), this.json = function () {
+              return this.text().then(JSON.parse);
+            }, this;
+          }
+
+          u.prototype.append = function (t, e) {
+            t = o(t), e = a(e);
+            var r = this.map[t];
+            this.map[t] = r ? r + ", " + e : e;
+          }, u.prototype.delete = function (t) {
+            delete this.map[o(t)];
+          }, u.prototype.get = function (t) {
+            return t = o(t), this.has(t) ? this.map[t] : null;
+          }, u.prototype.has = function (t) {
+            return this.map.hasOwnProperty(o(t));
+          }, u.prototype.set = function (t, e) {
+            this.map[o(t)] = a(e);
+          }, u.prototype.forEach = function (t, e) {
+            for (var r in this.map) this.map.hasOwnProperty(r) && t.call(e, this.map[r], r, this);
+          }, u.prototype.keys = function () {
+            var t = [];
+            return this.forEach(function (e, r) {
+              t.push(r);
+            }), s(t);
+          }, u.prototype.values = function () {
+            var t = [];
+            return this.forEach(function (e) {
+              t.push(e);
+            }), s(t);
+          }, u.prototype.entries = function () {
+            var t = [];
+            return this.forEach(function (e, r) {
+              t.push([r, e]);
+            }), s(t);
+          }, r.iterable && (u.prototype[Symbol.iterator] = u.prototype.entries);
+          var p = ["DELETE", "GET", "HEAD", "OPTIONS", "POST", "PUT"];
+
+          function g(t, e) {
+            var r,
+                n,
+                i = (e = e || {}).body;
+
+            if (t instanceof g) {
+              if (t.bodyUsed) throw new TypeError("Already read");
+              this.url = t.url, this.credentials = t.credentials, e.headers || (this.headers = new u(t.headers)), this.method = t.method, this.mode = t.mode, this.signal = t.signal, i || null == t._bodyInit || (i = t._bodyInit, t.bodyUsed = !0);
+            } else this.url = String(t);
+
+            if (this.credentials = e.credentials || this.credentials || "same-origin", !e.headers && this.headers || (this.headers = new u(e.headers)), this.method = (r = e.method || this.method || "GET", n = r.toUpperCase(), p.indexOf(n) > -1 ? n : r), this.mode = e.mode || this.mode || null, this.signal = e.signal || this.signal, this.referrer = null, ("GET" === this.method || "HEAD" === this.method) && i) throw new TypeError("Body not allowed for GET or HEAD requests");
+
+            this._initBody(i);
+          }
+
+          function v(t) {
+            var e = new FormData();
+            return t.trim().split("&").forEach(function (t) {
+              if (t) {
+                var r = t.split("="),
+                    n = r.shift().replace(/\+/g, " "),
+                    i = r.join("=").replace(/\+/g, " ");
+                e.append(decodeURIComponent(n), decodeURIComponent(i));
+              }
+            }), e;
+          }
+
+          function y(t, e) {
+            e || (e = {}), this.type = "default", this.status = void 0 === e.status ? 200 : e.status, this.ok = this.status >= 200 && this.status < 300, this.statusText = "statusText" in e ? e.statusText : "OK", this.headers = new u(e.headers), this.url = e.url || "", this._initBody(t);
+          }
+
+          g.prototype.clone = function () {
+            return new g(this, {
+              body: this._bodyInit
+            });
+          }, d.call(g.prototype), d.call(y.prototype), y.prototype.clone = function () {
+            return new y(this._bodyInit, {
+              status: this.status,
+              statusText: this.statusText,
+              headers: new u(this.headers),
+              url: this.url
+            });
+          }, y.error = function () {
+            var t = new y(null, {
+              status: 0,
+              statusText: ""
+            });
+            return t.type = "error", t;
+          };
+          var m = [301, 302, 303, 307, 308];
+          y.redirect = function (t, e) {
+            if (-1 === m.indexOf(e)) throw new RangeError("Invalid status code");
+            return new y(null, {
+              status: e,
+              headers: {
+                location: t
+              }
+            });
+          }, e.DOMException = t.DOMException;
+
+          try {
+            new e.DOMException();
+          } catch (t) {
+            e.DOMException = function (t, e) {
+              this.message = t, this.name = e;
+              var r = Error(t);
+              this.stack = r.stack;
+            }, e.DOMException.prototype = Object.create(Error.prototype), e.DOMException.prototype.constructor = e.DOMException;
+          }
+
+          function b(t, n) {
+            return new Promise(function (i, o) {
+              var a = new g(t, n);
+              if (a.signal && a.signal.aborted) return o(new e.DOMException("Aborted", "AbortError"));
+              var s = new XMLHttpRequest();
+
+              function f() {
+                s.abort();
+              }
+
+              s.onload = function () {
+                var t,
+                    e,
+                    r = {
+                  status: s.status,
+                  statusText: s.statusText,
+                  headers: (t = s.getAllResponseHeaders() || "", e = new u(), t.replace(/\r?\n[\t ]+/g, " ").split(/\r?\n/).forEach(function (t) {
+                    var r = t.split(":"),
+                        n = r.shift().trim();
+
+                    if (n) {
+                      var i = r.join(":").trim();
+                      e.append(n, i);
+                    }
+                  }), e)
+                };
+                r.url = "responseURL" in s ? s.responseURL : r.headers.get("X-Request-URL");
+                var n = "response" in s ? s.response : s.responseText;
+                i(new y(n, r));
+              }, s.onerror = function () {
+                o(new TypeError("Network request failed"));
+              }, s.ontimeout = function () {
+                o(new TypeError("Network request failed"));
+              }, s.onabort = function () {
+                o(new e.DOMException("Aborted", "AbortError"));
+              }, s.open(a.method, a.url, !0), "include" === a.credentials ? s.withCredentials = !0 : "omit" === a.credentials && (s.withCredentials = !1), "responseType" in s && r.blob && (s.responseType = "blob"), a.headers.forEach(function (t, e) {
+                s.setRequestHeader(e, t);
+              }), a.signal && (a.signal.addEventListener("abort", f), s.onreadystatechange = function () {
+                4 === s.readyState && a.signal.removeEventListener("abort", f);
+              }), s.send(void 0 === a._bodyInit ? null : a._bodyInit);
+            });
+          }
+
+          b.polyfill = !0, t.fetch || (t.fetch = b, t.Headers = u, t.Request = g, t.Response = y), e.Headers = u, e.Request = g, e.Response = y, e.fetch = b;
+        }({});
+      }(r), delete r.fetch.polyfill, (e = r.fetch).default = r.fetch, e.fetch = r.fetch, e.Headers = r.Headers, e.Request = r.Request, e.Response = r.Response, t.exports = e;
+    }, function (t, e, r) {
+
+      var n = r(1),
+          i = n(r(30)),
+          o = n(r(16)),
+          a = n(r(76)),
+          s = n(r(31)),
+          u = n(r(7)),
+          f = n(r(10)),
+          c = r(94),
+          l = function () {
+        function t(e) {
+          var r = e.fetch,
+              n = e.size,
+              i = void 0 === n ? 1e7 : n,
+              o = e.chunkSize,
+              a = void 0 === o ? 32768 : o;
+          if ((0, u.default)(this, t), !r) throw new Error("fetch function required");
+          this.fetch = r, this.chunkSize = a, this.lruCache = new c({
+            maxSize: Math.floor(i / a)
+          });
+        }
+
+        var e;
+        return (0, f.default)(t, [{
+          key: "get",
+          value: (e = (0, s.default)(i.default.mark(function t(e, r, n, s) {
+            var u,
+                f,
+                c,
+                l,
+                h,
+                d,
+                p,
+                g = this;
+            return i.default.wrap(function (t) {
+              for (;;) switch (t.prev = t.next) {
+                case 0:
+                  if (!(e.length < r + n)) {
+                    t.next = 2;
+                    break;
+                  }
+
+                  throw new Error("output buffer not big enough for request");
+
+                case 2:
+                  for (u = Math.floor(s / this.chunkSize), f = Math.floor((s + n) / this.chunkSize), c = new Array(f - u + 1), l = function (t) {
+                    c[t - u] = g._getChunk(t).then(function (e) {
+                      return {
+                        data: e,
+                        chunkNumber: t
+                      };
+                    });
+                  }, h = u; h <= f; h += 1) l(h);
+
+                  return t.next = 9, a.default.all(c);
+
+                case 9:
+                  d = t.sent, p = s - d[0].chunkNumber * this.chunkSize, (0, o.default)(d).call(d, function (t) {
+                    var i = t.data,
+                        o = t.chunkNumber,
+                        a = o * g.chunkSize,
+                        c = 0,
+                        l = g.chunkSize,
+                        h = r + (o - u) * g.chunkSize - p;
+                    o === u && (h = r, c = p), o === f && (l = s + n - a), i.copy(e, h, c, l);
+                  });
+
+                case 12:
+                case "end":
+                  return t.stop();
+              }
+            }, t, this);
+          })), function (t, r, n, i) {
+            return e.apply(this, arguments);
+          })
+        }, {
+          key: "_getChunk",
+          value: function (t) {
+            var e = this.lruCache.get(t);
+            if (e) return e;
+            var r = this.fetch(t * this.chunkSize, this.chunkSize);
+            return this.lruCache.set(t, r), r;
+          }
+        }]), t;
+      }();
+
+      t.exports = l;
+    }, function (t, e, r) {
+
+      var n = r(1),
+          i = n(r(30)),
+          o = n(r(31)),
+          a = n(r(7)),
+          s = n(r(10)),
+          u = (r(161).promisify, null),
+          f = u,
+          c = function () {
+        function t(e) {
+          (0, a.default)(this, t), this.position = 0, this.filename = e, this.fd = f(this.filename, "r");
+        }
+
+        var e, r, n;
+        return (0, s.default)(t, [{
+          key: "read",
+          value: (n = (0, o.default)(i.default.mark(function t(e) {
+            var r,
+                n,
+                o,
+                a = arguments;
+            return i.default.wrap(function (t) {
+              for (;;) switch (t.prev = t.next) {
+                case 0:
+                  return r = a.length > 1 && void 0 !== a[1] ? a[1] : 0, n = a.length > 2 ? a[2] : void 0, null === (o = a.length > 3 ? a[3] : void 0) && (this.position, this.position += n), t.t0 = null, t.next = 8, this.fd;
+
+                case 8:
+                  return t.t1 = t.sent, t.t2 = e, t.t3 = r, t.t4 = n, t.t5 = o, t.abrupt("return", (0, t.t0)(t.t1, t.t2, t.t3, t.t4, t.t5));
+
+                case 14:
+                case "end":
+                  return t.stop();
+              }
+            }, t, this);
+          })), function (t) {
+            return n.apply(this, arguments);
+          })
+        }, {
+          key: "readFile",
+          value: (r = (0, o.default)(i.default.mark(function t() {
+            return i.default.wrap(function (t) {
+              for (;;) switch (t.prev = t.next) {
+                case 0:
+                  return t.t0 = null, t.next = 3, this.fd;
+
+                case 3:
+                  return t.t1 = t.sent, t.abrupt("return", (0, t.t0)(t.t1));
+
+                case 5:
+                case "end":
+                  return t.stop();
+              }
+            }, t, this);
+          })), function () {
+            return r.apply(this, arguments);
+          })
+        }, {
+          key: "stat",
+          value: (e = (0, o.default)(i.default.mark(function t() {
+            return i.default.wrap(function (t) {
+              for (;;) switch (t.prev = t.next) {
+                case 0:
+                  if (this._stat) {
+                    t.next = 8;
+                    break;
+                  }
+
+                  return t.t0 = null, t.next = 4, this.fd;
+
+                case 4:
+                  return t.t1 = t.sent, t.next = 7, (0, t.t0)(t.t1);
+
+                case 7:
+                  this._stat = t.sent;
+
+                case 8:
+                  return t.abrupt("return", this._stat);
+
+                case 9:
+                case "end":
+                  return t.stop();
+              }
+            }, t, this);
+          })), function () {
+            return e.apply(this, arguments);
+          })
+        }]), t;
+      }();
+
+      t.exports = c;
+    }, function (t, e, r) {
+
+      var n = r(1),
+          i = n(r(48)),
+          o = n(r(77)),
+          a = n(r(101)),
+          s = n(r(431)),
+          u = n(r(16));
+      t.exports = {
+        parseHeaderText: function (t) {
+          var e = t.split(/\r?\n/),
+              r = [];
+          return (0, u.default)(e).call(e, function (t) {
+            var e = t.split(/\t/),
+                n = (0, s.default)(e),
+                u = n[0],
+                f = (0, a.default)(n).call(n, 1),
+                c = (0, o.default)(f).call(f, function (t) {
+              var e = t.split(":", 2),
+                  r = (0, i.default)(e, 2);
+              return {
+                tag: r[0],
+                value: r[1]
+              };
+            });
+            u && r.push({
+              tag: u.substr(1),
+              data: c
+            });
+          }), r;
+        }
+      };
+    }, function (t, e, r) {
+      var n = r(157),
+          i = r(152),
+          o = r(158);
+
+      t.exports = function (t) {
+        return n(t) || i(t) || o();
+      };
+    }, function (t, e, r) {
+
+      var n = r(1),
+          i = n(r(30)),
+          o = n(r(103)),
+          a = n(r(150)),
+          s = n(r(48)),
+          u = n(r(102)),
+          f = n(r(16)),
+          c = n(r(59)),
+          l = n(r(76)),
+          h = n(r(37)),
+          d = n(r(77)),
+          p = n(r(433)),
+          g = n(r(31)),
+          v = n(r(7)),
+          y = n(r(10)),
+          m = r(9),
+          b = m.CramUnimplementedError,
+          _ = m.CramSizeLimitError,
+          w = r(104),
+          x = function () {
+        function t(e) {
+          if ((0, v.default)(this, t), e.cram ? this.cram = e.cram : this.cram = new w({
+            url: e.cramUrl,
+            path: e.cramPath,
+            filehandle: e.cramFilehandle,
+            seqFetch: e.seqFetch,
+            checkSequenceMD5: e.checkSequenceMD5,
+            cacheSize: e.cacheSize
+          }), !(this.cram instanceof w)) throw new Error("invalid arguments: no cramfile");
+          if (this.index = e.index, !this.index.getEntriesForRange) throw new Error("invalid arguments: not an index");
+          this.fetchSizeLimit = e.fetchSizeLimit || 3e6;
+        }
+
+        var e;
+        return (0, y.default)(t, [{
+          key: "getRecordsForRange",
+          value: (e = (0, g.default)(i.default.mark(function t(e, r, n) {
+            var g,
+                v,
+                y,
+                m,
+                w,
+                x,
+                E,
+                S,
+                k,
+                A,
+                C,
+                T,
+                R,
+                O,
+                I,
+                L,
+                B,
+                P,
+                F,
+                N,
+                M,
+                j,
+                z,
+                U,
+                D,
+                q,
+                Z,
+                H,
+                V,
+                G,
+                Y,
+                W,
+                K,
+                Q,
+                X,
+                $ = this,
+                J = arguments;
+            return i.default.wrap(function (t) {
+              for (;;) switch (t.prev = t.next) {
+                case 0:
+                  if ((x = J.length > 3 && void 0 !== J[3] ? J[3] : {}).viewAsPairs = x.viewAsPairs || !1, x.pairAcrossChr = x.pairAcrossChr || !1, x.maxInsertSize = x.maxInsertSize || 2e5, "string" != typeof e) {
+                    t.next = 6;
+                    break;
+                  }
+
+                  throw new b("string sequence names not yet supported");
+
+                case 6:
+                  return E = e, t.next = 9, this.index.getEntriesForRange(E, r, n);
+
+                case 9:
+                  if (S = t.sent, !((k = (0, p.default)(g = (0, d.default)(S).call(S, function (t) {
+                    return t.sliceBytes;
+                  })).call(g, function (t, e) {
+                    return t + e;
+                  }, 0)) > this.fetchSizeLimit)) {
+                    t.next = 13;
+                    break;
+                  }
+
+                  throw new _((0, h.default)(v = "data size of ".concat(k.toLocaleString(), " bytes exceeded fetch size limit of ")).call(v, this.fetchSizeLimit.toLocaleString(), " bytes"));
+
+                case 13:
+                  return A = function (t) {
+                    return t.sequenceId === e && t.alignmentStart <= n && t.alignmentStart + t.lengthOnRef - 1 >= r;
+                  }, t.next = 16, l.default.all((0, d.default)(S).call(S, function (t) {
+                    return $.getRecordsInSlice(t, A);
+                  }));
+
+                case 16:
+                  if (C = t.sent, T = (m = (0, h.default)(y = Array.prototype)).call.apply(m, (0, h.default)(w = [y]).call(w, (0, c.default)(C))), !x.viewAsPairs) {
+                    t.next = 42;
+                    break;
+                  }
+
+                  for (L = {}, B = {}, P = 0; P < T.length; P += 1) F = T[P].readName, N = T[P].uniqueId, L[F] || (L[F] = 0), L[F] += 1, B[N] = 1;
+
+                  for (M = {}, (0, f.default)(R = (0, u.default)(L)).call(R, function (t) {
+                    var e = (0, s.default)(t, 2),
+                        r = e[0];
+                    1 === e[1] && (M[r] = !0);
+                  }), j = [], z = 0; z < T.length; z += 1) U = T[z].readName, M[U] && T[z].mate && (T[z].mate.sequenceId === E || x.pairAcrossChr) && Math.abs(T[z].alignmentStart - T[z].mate.alignmentStart) < x.maxInsertSize && (D = this.index.getEntriesForRange(T[z].mate.sequenceId, T[z].mate.alignmentStart, T[z].mate.alignmentStart + 1), j.push(D));
+
+                  return t.next = 28, l.default.all(j);
+
+                case 28:
+                  for (q = t.sent, Z = [], H = 0; H < q.length; H += 1) (V = Z).push.apply(V, (0, c.default)(q[H]));
+
+                  if (Z = (0, a.default)(O = (0, o.default)(Z).call(Z, function (t, e) {
+                    return t.toString().localeCompare(e.toString());
+                  })).call(O, function (t, e, r) {
+                    return !e || t.toString() !== r[e - 1].toString();
+                  }), G = [], Y = [], !((W = (0, p.default)(I = (0, d.default)(Z).call(Z, function (t) {
+                    return t.sliceBytes;
+                  })).call(I, function (t, e) {
+                    return t + e;
+                  }, 0)) > this.fetchSizeLimit)) {
+                    t.next = 37;
+                    break;
+                  }
+
+                  throw new Error((0, h.default)(K = "mate data size of ".concat(W.toLocaleString(), " bytes exceeded fetch size limit of ")).call(K, this.fetchSizeLimit.toLocaleString(), " bytes"));
+
+                case 37:
+                  return (0, f.default)(Z).call(Z, function (t) {
+                    var e = $.cram.featureCache.get(t.toString());
+                    e || (e = $.getRecordsInSlice(t, function () {
+                      return !0;
+                    }), $.cram.featureCache.set(t.toString(), e)), G.push(e);
+                    var r = e.then(function (t) {
+                      for (var e = [], r = 0; r < t.length; r += 1) {
+                        var n = t[r];
+                        M[n.readName] && !B[n.uniqueId] && e.push(n);
+                      }
+
+                      return e;
+                    });
+                    Y.push(r);
+                  }), t.next = 40, l.default.all(Y);
+
+                case 40:
+                  (Q = t.sent).length && (X = (0, p.default)(Q).call(Q, function (t, e) {
+                    return (0, h.default)(t).call(t, e);
+                  }), T = (0, h.default)(T).call(T, X));
+
+                case 42:
+                  return t.abrupt("return", T);
+
+                case 43:
+                case "end":
+                  return t.stop();
+              }
+            }, t, this);
+          })), function (t, r, n) {
+            return e.apply(this, arguments);
+          })
+        }, {
+          key: "getRecordsInSlice",
+          value: function (t, e) {
+            var r = t.containerStart,
+                n = t.sliceStart,
+                i = t.sliceBytes;
+            return this.cram.getContainerAtPosition(r).getSlice(n, i).getRecords(e);
+          }
+        }, {
+          key: "hasDataForReferenceSequence",
+          value: function (t) {
+            return this.index.hasDataForReferenceSequence(t);
+          }
+        }]), t;
+      }();
+
+      t.exports = x;
+    }, function (t, e, r) {
+      t.exports = r(434);
+    }, function (t, e, r) {
+      t.exports = r(435);
+    }, function (t, e, r) {
+      var n = r(436),
+          i = Array.prototype;
+
+      t.exports = function (t) {
+        var e = t.reduce;
+        return t === i || t instanceof Array && e === i.reduce ? n : e;
+      };
+    }, function (t, e, r) {
+      r(437);
+      var n = r(18);
+      t.exports = n("Array").reduce;
+    }, function (t, e, r) {
+
+      var n = r(0),
+          i = r(438).left;
+      n({
+        target: "Array",
+        proto: !0,
+        forced: r(54)("reduce")
+      }, {
+        reduce: function (t) {
+          return i(this, t, arguments.length, arguments.length > 1 ? arguments[1] : void 0);
+        }
+      });
+    }, function (t, e, r) {
+      var n = r(5),
+          i = r(22),
+          o = r(60),
+          a = r(29),
+          s = function (t) {
+        return function (e, r, s, u) {
+          n(r);
+          var f = i(e),
+              c = o(f),
+              l = a(f.length),
+              h = t ? l - 1 : 0,
+              d = t ? -1 : 1;
+          if (s < 2) for (;;) {
+            if (h in c) {
+              u = c[h], h += d;
+              break;
+            }
+
+            if (h += d, t ? h < 0 : l <= h) throw TypeError("Reduce of empty array with no initial value");
+          }
+
+          for (; t ? h >= 0 : l > h; h += d) h in c && (u = r(u, c[h], h, f));
+
+          return u;
+        };
+      };
+
+      t.exports = {
+        left: s(!1),
+        right: s(!0)
+      };
+    }, function (t, e, r) {
+
+      var n = r(1),
+          i = n(r(30)),
+          o = n(r(31)),
+          a = n(r(103)),
+          s = n(r(102)),
+          u = n(r(16)),
+          f = n(r(154)),
+          c = n(r(440)),
+          l = n(r(48)),
+          h = n(r(442)),
+          d = n(r(37)),
+          p = n(r(75)),
+          g = n(r(7)),
+          v = n(r(10)),
+          y = r(447).default,
+          m = r(94),
+          b = (0, r(161).promisify)(r(126).gunzip),
+          _ = r(160).open,
+          w = r(9).CramMalformedError,
+          x = function () {
+        function t(e) {
+          (0, g.default)(this, t), (0, p.default)(this, e);
+        }
+
+        return (0, v.default)(t, [{
+          key: "toString",
+          value: function () {
+            var t, e, r, n;
+            return (0, d.default)(t = (0, d.default)(e = (0, d.default)(r = (0, d.default)(n = "".concat(this.start, ":")).call(n, this.span, ":")).call(r, this.containerStart, ":")).call(e, this.sliceStart, ":")).call(t, this.sliceBytes);
+          }
+        }]), t;
+      }();
+
+      function E(t, e) {
+        if ((0, h.default)(e).call(e, function (t) {
+          return void 0 === t;
+        })) throw new w("invalid .crai index file");
+        var r = (0, l.default)(e, 6),
+            n = r[0],
+            i = r[1],
+            o = r[2],
+            a = r[3],
+            s = r[4],
+            u = r[5];
+        t[n] || (t[n] = []), t[n].push(new x({
+          start: i,
+          span: o,
+          containerStart: a,
+          sliceStart: s,
+          sliceBytes: u
+        }));
+      }
+
+      var S = function () {
+        function t(e) {
+          var r,
+              n = this;
+          (0, g.default)(this, t);
+
+          var i = _(e.url, e.path, e.filehandle);
+
+          this._parseCache = new y({
+            cache: new m({
+              maxSize: 1
+            }),
+            fill: function (t, e) {
+              return n.parseIndex({
+                signal: e
+              });
+            }
+          }), this.readFile = (0, c.default)(r = i.readFile).call(r, i);
+        }
+
+        var e, r;
+        return (0, v.default)(t, [{
+          key: "parseIndex",
+          value: function () {
+            var t = {};
+            return this.readFile().then(function (t) {
+              return 31 === t[0] && 139 === t[1] ? b(t) : t;
+            }).then(function (e) {
+              var r;
+              if (e.length > 4 && 21578050 === e.readUInt32LE(0)) throw new w("invalid .crai index file. note: file appears to be a .bai index. this is technically legal but please open a github issue if you need support");
+
+              for (var n = [], i = "", o = 0; o < e.length; o += 1) {
+                var c = e[o];
+                if (c >= 48 && c <= 57 || !i && 45 === c) i += String.fromCharCode(c);else if (9 === c) n.push((0, f.default)(i, 10)), i = "";else if (10 === c) n.push((0, f.default)(i, 10)), i = "", E(t, n), n = [];else if (13 !== c && 32 !== c) throw new w("invalid .crai index file");
+              }
+
+              return i && n.push((0, f.default)(i, 10)), 6 === n.length && E(t, n), (0, u.default)(r = (0, s.default)(t)).call(r, function (e) {
+                var r = (0, l.default)(e, 2),
+                    n = r[0],
+                    i = r[1];
+                t[n] = (0, a.default)(i).call(i, function (t, e) {
+                  return t.start - e.start || t.span - e.span;
+                });
+              }), t;
+            });
+          }
+        }, {
+          key: "getIndex",
+          value: function () {
+            var t = arguments.length > 0 && void 0 !== arguments[0] ? arguments[0] : {};
+            return this._parseCache.get("index", null, t.signal);
+          }
+        }, {
+          key: "hasDataForReferenceSequence",
+          value: (r = (0, o.default)(i.default.mark(function t(e) {
+            return i.default.wrap(function (t) {
+              for (;;) switch (t.prev = t.next) {
+                case 0:
+                  return t.next = 2, this.getIndex();
+
+                case 2:
+                  return t.t0 = e, t.abrupt("return", !!t.sent[t.t0]);
+
+                case 4:
+                case "end":
+                  return t.stop();
+              }
+            }, t, this);
+          })), function (t) {
+            return r.apply(this, arguments);
+          })
+        }, {
+          key: "getEntriesForRange",
+          value: (e = (0, o.default)(i.default.mark(function t(e, r, n) {
+            var o, a, s, u;
+            return i.default.wrap(function (t) {
+              for (;;) switch (t.prev = t.next) {
+                case 0:
+                  return t.next = 2, this.getIndex();
+
+                case 2:
+                  if (t.t0 = e, o = t.sent[t.t0]) {
+                    t.next = 6;
+                    break;
+                  }
+
+                  return t.abrupt("return", []);
+
+                case 6:
+                  for (a = function (t) {
+                    var e = t.start,
+                        i = t.start + t.span;
+                    return e >= n ? -1 : i <= r ? 1 : 0;
+                  }, s = [], u = 0; u < o.length; u += 1) 0 === a(o[u]) && s.push(o[u]);
+
+                  return t.abrupt("return", s);
+
+                case 10:
+                case "end":
+                  return t.stop();
+              }
+            }, t, this);
+          })), function (t, r, n) {
+            return e.apply(this, arguments);
+          })
+        }]), t;
+      }();
+
+      t.exports = S;
+    }, function (t, e, r) {
+      t.exports = r(441);
+    }, function (t, e, r) {
+      t.exports = r(144);
+    }, function (t, e, r) {
+      t.exports = r(443);
+    }, function (t, e, r) {
+      t.exports = r(444);
+    }, function (t, e, r) {
+      var n = r(445),
+          i = Array.prototype;
+
+      t.exports = function (t) {
+        var e = t.some;
+        return t === i || t instanceof Array && e === i.some ? n : e;
+      };
+    }, function (t, e, r) {
+      r(446);
+      var n = r(18);
+      t.exports = n("Array").some;
+    }, function (t, e, r) {
+
+      var n = r(0),
+          i = r(45).some;
+      n({
+        target: "Array",
+        proto: !0,
+        forced: r(54)("some")
+      }, {
+        some: function (t) {
+          return i(this, t, arguments.length > 1 ? arguments[1] : void 0);
+        }
+      });
+    }, function (t, e, r) {
+
+      var n = this && this.__importDefault || function (t) {
+        return t && t.__esModule ? t : {
+          default: t
+        };
+      };
+
+      Object.defineProperty(e, "__esModule", {
+        value: !0
+      });
+      var i = n(r(448));
+      e.default = i.default;
+    }, function (t, e, r) {
+
+      var n = this && this.__importDefault || function (t) {
+        return t && t.__esModule ? t : {
+          default: t
+        };
+      };
+
+      Object.defineProperty(e, "__esModule", {
+        value: !0
+      });
+
+      var i = r(162),
+          o = n(r(450)),
+          a = function () {
+        function t(t) {
+          var e = t.fill,
+              r = t.cache;
+          if ("function" != typeof e) throw new TypeError("must pass a fill function");
+          if ("object" != typeof r) throw new TypeError("must pass a cache object");
+          if ("function" != typeof r.get || "function" != typeof r.set || "function" != typeof r.delete) throw new TypeError("cache must implement get(key), set(key, val), and and delete(key)");
+          this.cache = r, this.fillCallback = e;
+        }
+
+        return t.isAbortException = function (t) {
+          return "AbortError" === t.name || "ERR_ABORTED" === t.code || "AbortError: aborted" === t.message || "Error: aborted" === t.message;
+        }, t.prototype.evict = function (t, e) {
+          this.cache.get(t) === e && this.cache.delete(t);
+        }, t.prototype.fill = function (t, e, r) {
+          var n = this,
+              i = new o.default(),
+              a = {
+            aborter: i,
+            promise: this.fillCallback(e, i.signal),
+            settled: !1,
+
+            get aborted() {
+              return this.aborter.signal.aborted;
+            }
+
+          };
+          a.aborter.addSignal(r), a.aborter.signal.addEventListener("abort", function () {
+            n.evict(t, a);
+          }), a.promise.then(function () {
+            a.settled = !0;
+          }, function (e) {
+            a.settled = !0, n.evict(t, a);
+          }).catch(function (t) {
+            throw console.error(t), t;
+          }), this.cache.set(t, a);
+        }, t.checkSinglePromise = function (t, e) {
+          function r() {
+            if (e && e.aborted) throw Object.assign(new Error("aborted"), {
+              code: "ERR_ABORTED"
+            });
+          }
+
+          return t.then(function (t) {
+            return r(), t;
+          }, function (t) {
+            throw r(), t;
+          });
+        }, t.prototype.has = function (t) {
+          return this.cache.has(t);
+        }, t.prototype.get = function (e, r, n) {
+          if (!n && r instanceof i.AbortSignal) throw new TypeError("second get argument appears to be an AbortSignal, perhaps you meant to pass `null` for the fill data?");
+          var o = this.cache.get(e);
+          return o ? o.aborted ? (this.evict(e, o), this.get(e, r, n)) : o.settled ? o.promise : (o.aborter.addSignal(n), t.checkSinglePromise(o.promise, n)) : (this.fill(e, r, n), t.checkSinglePromise(this.cache.get(e).promise, n));
+        }, t.prototype.delete = function (t) {
+          var e = this.cache.get(t);
+          e && (e.settled || e.aborter.abort(), this.cache.delete(t));
+        }, t.prototype.clear = function () {
+          for (var t = this.cache.keys(), e = 0, r = t.next(); !r.done; r = t.next()) this.delete(r.value), e += 1;
+
+          return e;
+        }, t;
+      }();
+
+      e.default = a;
+    }, function (t, e, r) {
+
+      function n(t, e) {
+        if (!(t instanceof e)) throw new TypeError("Cannot call a class as a function");
+      }
+
+      function i(t, e) {
+        for (var r = 0; r < e.length; r++) {
+          var n = e[r];
+          n.enumerable = n.enumerable || !1, n.configurable = !0, "value" in n && (n.writable = !0), Object.defineProperty(t, n.key, n);
+        }
+      }
+
+      function o(t, e, r) {
+        return e && i(t.prototype, e), r && i(t, r), t;
+      }
+
+      function a(t) {
+        return (a = Object.setPrototypeOf ? Object.getPrototypeOf : function (t) {
+          return t.__proto__ || Object.getPrototypeOf(t);
+        })(t);
+      }
+
+      function s(t, e) {
+        return (s = Object.setPrototypeOf || function (t, e) {
+          return t.__proto__ = e, t;
+        })(t, e);
+      }
+
+      function u(t) {
+        if (void 0 === t) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+        return t;
+      }
+
+      function f(t, e, r) {
+        return (f = "undefined" != typeof Reflect && Reflect.get ? Reflect.get : function (t, e, r) {
+          var n = function (t, e) {
+            for (; !Object.prototype.hasOwnProperty.call(t, e) && null !== (t = a(t)););
+
+            return t;
+          }(t, e);
+
+          if (n) {
+            var i = Object.getOwnPropertyDescriptor(n, e);
+            return i.get ? i.get.call(r) : i.value;
+          }
+        })(t, e, r || t);
+      }
+
+      Object.defineProperty(e, "__esModule", {
+        value: !0
+      });
+
+      var c = function () {
+        function t() {
+          n(this, t), Object.defineProperty(this, "listeners", {
+            value: {},
+            writable: !0,
+            configurable: !0
+          });
+        }
+
+        return o(t, [{
+          key: "addEventListener",
+          value: function (t, e) {
+            t in this.listeners || (this.listeners[t] = []), this.listeners[t].push(e);
+          }
+        }, {
+          key: "removeEventListener",
+          value: function (t, e) {
+            if (t in this.listeners) for (var r = this.listeners[t], n = 0, i = r.length; n < i; n++) if (r[n] === e) return void r.splice(n, 1);
+          }
+        }, {
+          key: "dispatchEvent",
+          value: function (t) {
+            var e = this;
+
+            if (t.type in this.listeners) {
+              for (var r = function (r) {
+                setTimeout(function () {
+                  return r.call(e, t);
+                });
+              }, n = this.listeners[t.type], i = 0, o = n.length; i < o; i++) r(n[i]);
+
+              return !t.defaultPrevented;
+            }
+          }
+        }]), t;
+      }(),
+          l = function (t) {
+        function e() {
+          var t;
+          return n(this, e), (t = function (t, e) {
+            return !e || "object" != typeof e && "function" != typeof e ? u(t) : e;
+          }(this, a(e).call(this))).listeners || c.call(u(t)), Object.defineProperty(u(t), "aborted", {
+            value: !1,
+            writable: !0,
+            configurable: !0
+          }), Object.defineProperty(u(t), "onabort", {
+            value: null,
+            writable: !0,
+            configurable: !0
+          }), t;
+        }
+
+        return function (t, e) {
+          if ("function" != typeof e && null !== e) throw new TypeError("Super expression must either be null or a function");
+          t.prototype = Object.create(e && e.prototype, {
+            constructor: {
+              value: t,
+              writable: !0,
+              configurable: !0
+            }
+          }), e && s(t, e);
+        }(e, t), o(e, [{
+          key: "toString",
+          value: function () {
+            return "[object AbortSignal]";
+          }
+        }, {
+          key: "dispatchEvent",
+          value: function (t) {
+            "abort" === t.type && (this.aborted = !0, "function" == typeof this.onabort && this.onabort.call(this, t)), f(a(e.prototype), "dispatchEvent", this).call(this, t);
+          }
+        }]), e;
+      }(c),
+          h = function () {
+        function t() {
+          n(this, t), Object.defineProperty(this, "signal", {
+            value: new l(),
+            writable: !0,
+            configurable: !0
+          });
+        }
+
+        return o(t, [{
+          key: "abort",
+          value: function () {
+            var t;
+
+            try {
+              t = new Event("abort");
+            } catch (e) {
+              "undefined" != typeof document ? document.createEvent ? (t = document.createEvent("Event")).initEvent("abort", !1, !1) : (t = document.createEventObject()).type = "abort" : t = {
+                type: "abort",
+                bubbles: !1,
+                cancelable: !1
+              };
+            }
+
+            this.signal.dispatchEvent(t);
+          }
+        }, {
+          key: "toString",
+          value: function () {
+            return "[object AbortController]";
+          }
+        }]), t;
+      }();
+
+      "undefined" != typeof Symbol && Symbol.toStringTag && (h.prototype[Symbol.toStringTag] = "AbortController", l.prototype[Symbol.toStringTag] = "AbortSignal"), e.AbortController = h, e.AbortSignal = l, e.abortableFetch = function (t) {
+        "function" == typeof t && (t = {
+          fetch: t
+        });
+        var e = t,
+            r = e.fetch,
+            n = e.Request,
+            i = void 0 === n ? r.Request : n,
+            o = e.AbortController,
+            a = e.__FORCE_INSTALL_ABORTCONTROLLER_POLYFILL,
+            s = void 0 !== a && a;
+        if (!function (t) {
+          return t.__FORCE_INSTALL_ABORTCONTROLLER_POLYFILL ? (!0) : "function" == typeof t.Request && !t.Request.prototype.hasOwnProperty("signal") || !t.AbortController;
+        }({
+          fetch: r,
+          Request: i,
+          AbortController: o,
+          __FORCE_INSTALL_ABORTCONTROLLER_POLYFILL: s
+        })) return {
+          fetch: r,
+          Request: u
+        };
+        var u = i;
+        (u && !u.prototype.hasOwnProperty("signal") || s) && ((u = function (t, e) {
+          var r;
+          e && e.signal && (r = e.signal, delete e.signal);
+          var n = new i(t, e);
+          return r && Object.defineProperty(n, "signal", {
+            writable: !1,
+            enumerable: !1,
+            configurable: !0,
+            value: r
+          }), n;
+        }).prototype = i.prototype);
+        var f = r;
+        return {
+          fetch: function (t, e) {
+            var r = u && u.prototype.isPrototypeOf(t) ? t.signal : e ? e.signal : void 0;
+
+            if (r) {
+              var n;
+
+              try {
+                n = new DOMException("Aborted", "AbortError");
+              } catch (t) {
+                (n = new Error("Aborted")).name = "AbortError";
+              }
+
+              if (r.aborted) return Promise.reject(n);
+              var i = new Promise(function (t, e) {
+                r.addEventListener("abort", function () {
+                  return e(n);
+                }, {
+                  once: !0
+                });
+              });
+              return e && e.signal && delete e.signal, Promise.race([i, f(t, e)]);
+            }
+
+            return f(t, e);
+          },
+          Request: u
+        };
+      };
+    }, function (t, e, r) {
+
+      Object.defineProperty(e, "__esModule", {
+        value: !0
+      });
+
+      var n = r(162),
+          i = function () {},
+          o = function () {
+        function t() {
+          this.signals = new Set(), this.abortController = new n.AbortController();
+        }
+
+        return t.prototype.addSignal = function (t) {
+          var e = this;
+          if (void 0 === t && (t = new i()), this.signal.aborted) throw new Error("cannot add a signal, already aborted!");
+          this.signals.add(t), t.aborted ? this.handleAborted(t) : "function" == typeof t.addEventListener && t.addEventListener("abort", function () {
+            e.handleAborted(t);
+          });
+        }, t.prototype.handleAborted = function (t) {
+          this.signals.delete(t), 0 === this.signals.size && this.abortController.abort();
+        }, Object.defineProperty(t.prototype, "signal", {
+          get: function () {
+            return this.abortController.signal;
+          },
+          enumerable: !0,
+          configurable: !0
+        }), t.prototype.abort = function () {
+          this.abortController.abort();
+        }, t;
+      }();
+
+      e.default = o;
+    }]);
+
+    /*
+     * The MIT License (MIT)
+     *
+     * Copyright (c) 2018 The Regents of the University of California
+     * Author: Jim Robinson
+     *
+     * Permission is hereby granted, free of charge, to any person obtaining a copy
+     * of this software and associated documentation files (the "Software"), to deal
+     * in the Software without restriction, including without limitation the rights
+     * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+     * copies of the Software, and to permit persons to whom the Software is
+     * furnished to do so, subject to the following conditions:
+     *
+     * The above copyright notice and this permission notice shall be included in
+     * all copies or substantial portions of the Software.
+     *
+     *
+     * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+     * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+     * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+     * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+     * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+     * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+     * THE SOFTWARE.
+     */
+    const READ_STRAND_FLAG = 0x10;
+    const MATE_STRAND_FLAG = 0x20;
+    const CRAM_MATE_STRAND_FLAG = 0x1;
+    /**
+     * Class for reading a cram file.  Wraps the gMOD Cram package.
+     *
+     * @param config
+     * @constructor
+     */
+
+    class CramReader {
+      constructor(config, genome, browser) {
+        this.config = config;
+        this.browser = browser;
+        this.genome = genome;
+        this.cramFile = new gmodCRAM.CramFile({
+          filehandle: new FileHandler(config.url, config),
+          seqFetch: config.seqFetch || seqFetch.bind(this),
+          checkSequenceMD5: config.checkSequenceMD5 !== undefined ? config.checkSequenceMD5 : true
+        });
+        const indexFileHandle = new FileHandler(config.indexURL, config);
+        this.indexedCramFile = new gmodCRAM.IndexedCramFile({
+          cram: this.cramFile,
+          index: new gmodCRAM.CraiIndex({
+            filehandle: indexFileHandle
+          }),
+          fetchSizeLimit: 30000000
+        });
+        BamUtils.setReaderDefaults(this, config);
+
+        function seqFetch(seqID, start, end) {
+          const sequence = this.genome.sequence;
+          const genome = this.genome;
+          return this.getHeader().then(function (header) {
+            const chr = genome.getChromosomeName(header.chrNames[seqID]);
+            return sequence.getSequence(chr, start - 1, end);
+          });
+        }
+      }
+      /**
+       * Parse the sequence dictionary from the SAM header and build chr name tables.  This function
+       * is public so it can be unit tested.
+       *
+       * @returns {PromiseLike<chrName, chrToIndex, chrAliasTable}>}
+       */
+
+
+      async getHeader() {
+        if (!this.header) {
+          const genome = this.genome;
+          const samHeader = await this.cramFile.getSamHeader();
+          const chrToIndex = {};
+          const chrNames = [];
+          const chrAliasTable = {};
+          const readGroups = [];
+
+          for (let line of samHeader) {
+            if ('SQ' === line.tag) {
+              for (let d of line.data) {
+                if (d.tag === "SN") {
+                  const seq = d.value;
+                  chrToIndex[seq] = chrNames.length;
+                  chrNames.push(seq);
+
+                  if (genome) {
+                    const alias = genome.getChromosomeName(seq);
+                    chrAliasTable[alias] = seq;
+                  }
+
+                  break;
+                }
+              }
+            } else if ('RG' === line.tag) {
+              readGroups.push(line.data);
+            }
+          }
+
+          this.header = {
+            chrNames: chrNames,
+            chrToIndex: chrToIndex,
+            chrAliasTable: chrAliasTable,
+            readGroups: readGroups
+          };
+        }
+
+        return this.header;
+      }
+
+      async readAlignments(chr, bpStart, bpEnd) {
+        this.browser;
+        const header = await this.getHeader();
+        const queryChr = header.chrAliasTable.hasOwnProperty(chr) ? header.chrAliasTable[chr] : chr;
+        const chrIdx = header.chrToIndex[queryChr];
+        const alignmentContainer = new AlignmentContainer(chr, bpStart, bpEnd, this.samplingWindowSize, this.samplingDepth, this.pairsSupported, this.alleleFreqThreshold);
+
+        if (chrIdx === undefined) {
+          return alignmentContainer;
+        } else {
+          try {
+            const records = await this.indexedCramFile.getRecordsForRange(chrIdx, bpStart, bpEnd);
+
+            for (let record of records) {
+              const refID = record.sequenceId;
+              const pos = record.alignmentStart;
+              const alignmentEnd = pos + record.lengthOnRef;
+
+              if (refID < 0) {
+                continue; // unmapped read
+              } else if (refID > chrIdx || pos > bpEnd) {
+                return; // off right edge, we're done
+              } else if (refID < chrIdx) {
+                continue; // Sequence to left of start, not sure this is possible
+              }
+
+              if (alignmentEnd < bpStart) {
+                continue;
+              } // Record out-of-range "to the left", skip to next one
+
+
+              const alignment = decodeCramRecord(record, header.chrNames);
+
+              if (this.filter.pass(alignment)) {
+                alignmentContainer.push(alignment);
+              }
+            }
+
+            alignmentContainer.finish();
+            return alignmentContainer;
+          } catch (error) {
+            let message = error.message;
+
+            if (message && message.indexOf("MD5") >= 0) {
+              message = "Sequence mismatch. Is this the correct genome for the loaded CRAM?";
+            }
+
+            Alert.presentAlert(new Error(message));
+            throw error;
+          }
+        }
+
+        function decodeCramRecord(record, chrNames) {
+          const alignment = new BamAlignment();
+          alignment.chr = chrNames[record.sequenceId];
+          alignment.start = record.alignmentStart - 1;
+          alignment.lengthOnRef = record.lengthOnRef;
+          alignment.flags = record.flags;
+          alignment.strand = !(record.flags & READ_STRAND_FLAG);
+          alignment.fragmentLength = record.templateLength || record.templateSize;
+          alignment.mq = record.mappingQuality;
+          alignment.end = record.alignmentStart + record.lengthOnRef;
+          alignment.readGroupId = record.readGroupId;
+
+          if (record.mate && record.mate.sequenceId !== undefined) {
+            const strand = record.mate.flags !== undefined ? !(record.mate.flags & CRAM_MATE_STRAND_FLAG) : !(record.flags & MATE_STRAND_FLAG);
+            alignment.mate = {
+              chr: chrNames[record.mate.sequenceId],
+              position: record.mate.alignmentStart,
+              strand: strand
+            };
+          }
+
+          alignment.seq = record.getReadBases();
+          alignment.qual = record.qualityScores;
+          alignment.tagDict = record.tags;
+          alignment.readName = record.readName; // TODO -- cigar encoded in tag?
+          // BamUtils.bam_tag2cigar(ba, blockEnd, p, lseq, alignment, cigarArray);
+
+          makeBlocks(record, alignment);
+
+          if (alignment.mate && alignment.start > alignment.mate.position && alignment.fragmentLength > 0) {
+            alignment.fragmentLength = -alignment.fragmentLength;
+          }
+
+          BamUtils.setPairOrientation(alignment);
+          return alignment;
+        }
+
+        function makeBlocks(cramRecord, alignment) {
+          const blocks = [];
+          let insertions;
+          let gaps;
+          let basesUsed = 0;
+          let cigarString = '';
+          alignment.scStart = alignment.start;
+          alignment.scLengthOnRef = alignment.lengthOnRef;
+
+          if (cramRecord.readFeatures) {
+            for (let feature of cramRecord.readFeatures) {
+              const code = feature.code;
+              const data = feature.data;
+              const readPos = feature.pos - 1;
+              const refPos = feature.refPos - 1;
+
+              switch (code) {
+                case 'S':
+                case 'I':
+                case 'i':
+                case 'N':
+                case 'D':
+                  if (readPos > basesUsed) {
+                    const len = readPos - basesUsed;
+                    blocks.push(new AlignmentBlock({
+                      start: refPos - len,
+                      seqOffset: basesUsed,
+                      len: len,
+                      type: 'M'
+                    }));
+                    basesUsed += len;
+                    cigarString += len + 'M';
+                  }
+
+                  if ('S' === code) {
+                    let scPos = refPos;
+                    alignment.scLengthOnRef += data.length;
+
+                    if (readPos === 0) {
+                      alignment.scStart -= data.length;
+                      scPos -= data.length;
+                    }
+
+                    const len = data.length;
+                    blocks.push(new AlignmentBlock({
+                      start: scPos,
+                      seqOffset: basesUsed,
+                      len: len,
+                      type: 'S'
+                    }));
+                    basesUsed += len;
+                    cigarString += len + code;
+                  } else if ('I' === code || 'i' === code) {
+                    if (insertions === undefined) {
+                      insertions = [];
+                    }
+
+                    const len = 'i' === code ? 1 : data.length;
+                    insertions.push(new AlignmentBlock({
+                      start: refPos,
+                      len: len,
+                      seqOffset: basesUsed,
+                      type: 'I'
+                    }));
+                    basesUsed += len;
+                    cigarString += len + code;
+                  } else if ('D' === code || 'N' === code) {
+                    if (!gaps) {
+                      gaps = [];
+                    }
+
+                    gaps.push({
+                      start: refPos,
+                      len: data,
+                      type: code
+                    });
+                    cigarString += data + code;
+                  }
+
+                  break;
+
+                case 'H':
+                case 'P':
+                  cigarString += data + code;
+                  break;
+
+              }
+            }
+          } // Last block
+
+
+          const len = cramRecord.readLength - basesUsed;
+
+          if (len > 0) {
+            blocks.push(new AlignmentBlock({
+              start: cramRecord.alignmentStart + cramRecord.lengthOnRef - len - 1,
+              seqOffset: basesUsed,
+              len: len,
+              type: 'M'
+            }));
+            cigarString += len + 'M';
+          }
+
+          alignment.blocks = blocks;
+          alignment.insertions = insertions;
+          alignment.gaps = gaps;
+          alignment.cigar = cigarString;
+        }
+      }
+
+    }
+
+    class FileHandler {
+      constructor(source, config) {
+        this.position = 0;
+        this.url = source;
+        this.config = config;
+        this.cache = new BufferCache({
+          fetch: (start, length) => this._fetch(start, length)
+        });
+      }
+
+      async _fetch(position, length) {
+        const loadRange = {
+          start: position,
+          size: length
+        };
+        this._stat = {
+          size: undefined
+        };
+        const arrayBuffer = await igvxhr.loadArrayBuffer(this.url, buildOptions(this.config, {
+          range: loadRange
+        }));
+        return Buffer.from(arrayBuffer);
+      }
+
+      async read(buffer, offset = 0, length = Infinity, position = 0) {
+        let readPosition = position;
+
+        if (readPosition === null) {
+          readPosition = this.position;
+          this.position += length;
+        }
+
+        return this.cache.get(buffer, offset, length, position);
+      }
+
+      async readFile() {
+        const arrayBuffer = await igvxhr.loadArrayBuffer(this.url, buildOptions(this.config));
+        return Buffer.from(arrayBuffer);
+      }
+
+      async stat() {
+        if (!this._stat) {
+          const buf = Buffer.allocUnsafe(10);
+          await this.read(buf, 0, 10, 0);
+          if (!this._stat) throw new Error(`unable to determine size of file at ${this.url}`);
+        }
+
+        return this._stat;
+      }
+
+    }
+
+    class BufferCache {
+      constructor({
+        fetch,
+        size = 10000000,
+        chunkSize = 32768
+      }) {
+        this.fetch = fetch;
+        this.chunkSize = chunkSize;
+        this.lruCache = new QuickLRU({
+          maxSize: Math.floor(size / chunkSize)
+        });
+      }
+
+      async get(outputBuffer, offset, length, position) {
+        if (outputBuffer.length < offset + length) throw new Error('output buffer not big enough for request'); // calculate the list of chunks involved in this fetch
+
+        const firstChunk = Math.floor(position / this.chunkSize);
+        const lastChunk = Math.floor((position + length) / this.chunkSize); // fetch them all as necessary
+
+        const fetches = new Array(lastChunk - firstChunk + 1);
+
+        for (let chunk = firstChunk; chunk <= lastChunk; chunk += 1) {
+          fetches[chunk - firstChunk] = this._getChunk(chunk).then(data => ({
+            data,
+            chunkNumber: chunk
+          }));
+        } // stitch together the response buffer using them
+
+
+        const chunks = await Promise.all(fetches);
+        const chunksOffset = position - chunks[0].chunkNumber * this.chunkSize;
+        chunks.forEach(({
+          data,
+          chunkNumber
+        }) => {
+          const chunkPositionStart = chunkNumber * this.chunkSize;
+          let copyStart = 0;
+          let copyEnd = this.chunkSize;
+          let copyOffset = offset + (chunkNumber - firstChunk) * this.chunkSize - chunksOffset;
+
+          if (chunkNumber === firstChunk) {
+            copyOffset = offset;
+            copyStart = chunksOffset;
+          }
+
+          if (chunkNumber === lastChunk) {
+            copyEnd = position + length - chunkPositionStart;
+          }
+
+          data.copy(outputBuffer, copyOffset, copyStart, copyEnd);
+        });
+      }
+
+      _getChunk(chunkNumber) {
+        const cachedPromise = this.lruCache.get(chunkNumber);
+        if (cachedPromise) return cachedPromise;
+        const freshPromise = this.fetch(chunkNumber * this.chunkSize, this.chunkSize);
+        this.lruCache.set(chunkNumber, freshPromise);
+        return freshPromise;
+      }
+
+    } // From https://github.com/sindresorhus/quick-lru
+
+    class QuickLRU {
+      constructor(options = {}) {
+        if (!(options.maxSize && options.maxSize > 0)) {
+          throw new TypeError('`maxSize` must be a number greater than 0');
+        }
+
+        this.maxSize = options.maxSize;
+        this.cache = new Map();
+        this.oldCache = new Map();
+        this._size = 0;
+      }
+
+      _set(key, value) {
+        this.cache.set(key, value);
+        this._size++;
+
+        if (this._size >= this.maxSize) {
+          this._size = 0;
+          this.oldCache = this.cache;
+          this.cache = new Map();
+        }
+      }
+
+      get(key) {
+        if (this.cache.has(key)) {
+          return this.cache.get(key);
+        }
+
+        if (this.oldCache.has(key)) {
+          const value = this.oldCache.get(key);
+
+          this._set(key, value);
+
+          return value;
+        }
+      }
+
+      set(key, value) {
+        if (this.cache.has(key)) {
+          this.cache.set(key, value);
+        } else {
+          this._set(key, value);
+        }
+
+        return this;
+      }
+
+      has(key) {
+        return this.cache.has(key) || this.oldCache.has(key);
+      }
+
+      peek(key) {
+        if (this.cache.has(key)) {
+          return this.cache.get(key);
+        }
+
+        if (this.oldCache.has(key)) {
+          return this.oldCache.get(key);
+        }
+      }
+
+      delete(key) {
+        const deleted = this.cache.delete(key);
+
+        if (deleted) {
+          this._size--;
+        }
+
+        return this.oldCache.delete(key) || deleted;
+      }
+
+      clear() {
+        this.cache.clear();
+        this.oldCache.clear();
+        this._size = 0;
+      }
+
+      *keys() {
+        for (const [key] of this) {
+          yield key;
+        }
+      }
+
+      *values() {
+        for (const [, value] of this) {
+          yield value;
+        }
+      }
+
+      *[Symbol.iterator]() {
+        for (const item of this.cache) {
+          yield item;
+        }
+
+        for (const item of this.oldCache) {
+          const [key] = item;
+
+          if (!this.cache.has(key)) {
+            yield item;
+          }
+        }
+      }
+
+      get size() {
+        let oldCacheSize = 0;
+
+        for (const key of this.oldCache.keys()) {
+          if (!this.cache.has(key)) {
+            oldCacheSize++;
+          }
+        }
+
+        return this._size + oldCacheSize;
+      }
+
+    }
+
+    /*
+     * The MIT License (MIT)
+     *
+     * Copyright (c) 2014 Broad Institute
+     *
+     * Permission is hereby granted, free of charge, to any person obtaining a copy
+     * of this software and associated documentation files (the "Software"), to deal
+     * in the Software without restriction, including without limitation the rights
+     * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+     * copies of the Software, and to permit persons to whom the Software is
+     * furnished to do so, subject to the following conditions:
+     *
+     * The above copyright notice and this permission notice shall be included in
+     * all copies or substantial portions of the Software.
+     *
+     *
+     * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+     * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+     * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+     * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+     * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+     * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+     * THE SOFTWARE.
+     */
+    var CigarOperationTable = {
+      "ALIGNMENT_MATCH": "M",
+      "INSERT": "I",
+      "DELETE": "D",
+      "SKIP": "N",
+      "CLIP_SOFT": "S",
+      "CLIP_HARD": "H",
+      "PAD": "P",
+      "SEQUENCE_MATCH": "=",
+      "SEQUENCE_MISMATCH": "X"
+    };
+
+    const Ga4ghAlignmentReader = function (config, genome) {
+      this.config = config;
+      this.genome = genome;
+      this.url = config.url;
+      this.filter = new BamFilter(config.filter);
+      this.readGroupSetIds = config.readGroupSetIds;
+      this.authKey = config.authKey; // Might be undefined or nill
+
+      this.samplingWindowSize = config.samplingWindowSize === undefined ? 100 : config.samplingWindowSize;
+      this.samplingDepth = config.samplingDepth === undefined ? 1000 : config.samplingDepth;
+
+      if (config.viewAsPairs) {
+        this.pairsSupported = true;
+      } else {
+        this.pairsSupported = config.pairsSupported === undefined ? true : config.pairsSupported;
+      }
+    };
+
+    Ga4ghAlignmentReader.prototype.readAlignments = function (chr, bpStart, bpEnd) {
+      const genome = this.genome;
+      const self = this;
+      return getChrAliasTable().then(function (chrAliasTable) {
+        var queryChr = chrAliasTable.hasOwnProperty(chr) ? chrAliasTable[chr] : chr,
+            readURL = self.url + "/reads/search";
+        return ga4ghSearch({
+          url: readURL,
+          body: {
+            "readGroupSetIds": [self.readGroupSetIds],
+            "referenceName": queryChr,
+            "start": bpStart,
+            "end": bpEnd,
+            "pageSize": "10000"
+          },
+          decode: decodeGa4ghReads,
+          results: new AlignmentContainer(chr, bpStart, bpEnd, self.samplingWindowSize, self.samplingDepth, self.pairsSupported, self.alleleFreqThreshold)
+        });
+      });
+
+      function getChrAliasTable() {
+        if (self.chrAliasTable) {
+          return Promise.resolve(self.chrAliasTable);
+        } else {
+          return self.readMetadata().then(function (json) {
+            self.chrAliasTable = {};
+
+            if (genome && json.readGroups && json.readGroups.length > 0) {
+              var referenceSetId = json.readGroups[0].referenceSetId;
+
+              if (referenceSetId) {
+                // Query for reference names to build an alias table (map of genome ref names -> dataset ref names)
+                var readURL = self.url + "/references/search";
+                return ga4ghSearch({
+                  url: readURL,
+                  body: {
+                    "referenceSetId": referenceSetId
+                  },
+                  decode: function (j) {
+                    return j.references;
+                  }
+                }).then(function (references) {
+                  references.forEach(function (ref) {
+                    var refName = ref.name,
+                        alias = genome.getChromosomeName(refName);
+                    self.chrAliasTable[alias] = refName;
+                  });
+                  return self.chrAliasTable;
+                });
+              } else {
+                // Try hardcoded constants -- workaround for non-compliant data at Google
+                populateChrAliasTable(self.chrAliasTable, self.config.datasetId);
+                return self.chrAliasTable;
+              }
+            } else {
+              // No browser object, can't build map.  This can occur when run from unit tests
+              return self.chrAliasTable;
+            }
+          });
+        }
+      }
+      /**
+       * Decode an array of ga4gh read records
+       *
+        */
+
+
+      function decodeGa4ghReads(j) {
+        var i,
+            jsonRecords = j.alignments,
+            len = jsonRecords.length,
+            alignment,
+            jsonAlignment,
+            cigarDecoded,
+            alignments = [],
+            mate,
+            blocks;
+
+        for (i = 0; i < len; i++) {
+          let record = jsonRecords[i];
+          alignment = new BamAlignment();
+          alignment.readName = record.fragmentName;
+          alignment.properPlacement = record.properPlacement;
+          alignment.duplicateFragment = record.duplicateFragment;
+          alignment.numberReads = record.numberReads;
+          alignment.fragmentLength = record.fragmentLength;
+          alignment.readNumber = record.readNumber;
+          alignment.failedVendorQualityChecks = record.failedVendorQualityChecks;
+          alignment.secondaryAlignment = record.secondaryAlignment;
+          alignment.supplementaryAlignment = record.supplementaryAlignment;
+          alignment.seq = record.alignedSequence;
+          alignment.qual = record.alignedQuality;
+          alignment.matePos = record.nextMatePosition;
+          alignment.tagDict = record.info;
+          alignment.flags = encodeFlags();
+          jsonAlignment = record.alignment;
+
+          if (jsonAlignment) {
+            alignment.mapped = true;
+            alignment.chr = record.alignment.position.referenceName;
+            if (genome) alignment.chr = genome.getChromosomeName(alignment.chr);
+            alignment.start = parseInt(record.alignment.position.position);
+            alignment.strand = !record.alignment.position.reverseStrand;
+            alignment.mq = record.alignment.mappingQuality;
+            alignment.cigar = encodeCigar(record.alignment.cigar);
+            cigarDecoded = translateCigar(record.alignment.cigar);
+            alignment.lengthOnRef = cigarDecoded.lengthOnRef;
+            blocks = makeBlocks(alignment, cigarDecoded.array);
+            alignment.blocks = blocks.blocks;
+            alignment.insertions = blocks.insertions;
+          } else {
+            alignment.mapped = false;
+          }
+
+          mate = record.nextMatePosition;
+
+          if (mate) {
+            alignment.mate = {
+              chr: mate.referenceFrame,
+              position: parseInt(mate.position),
+              strand: !mate.reverseStrand
+            };
+          }
+
+          if (self.filter.pass(alignment)) {
+            alignments.push(alignment);
+          }
+        }
+
+        return alignments; // Encode a cigar string -- used for popup text
+
+        function encodeCigar(cigarArray) {
+          var cigarString = "";
+          cigarArray.forEach(function (cigarUnit) {
+            var op = CigarOperationTable[cigarUnit.operation],
+                len = cigarUnit.operationLength;
+            cigarString = cigarString + (len + op);
+          });
+          return cigarString;
+        } // TODO -- implement me
+
+
+        function encodeFlags(json) {
+          return 0;
+        }
+
+        function translateCigar(cigar) {
+          var cigarUnit,
+              opLen,
+              opLtr,
+              lengthOnRef = 0,
+              cigarArray = [],
+              i;
+
+          for (i = 0; i < cigar.length; i++) {
+            cigarUnit = cigar[i];
+            opLtr = CigarOperationTable[cigarUnit.operation];
+            opLen = parseInt(cigarUnit.operationLength); // Google represents long as a String
+
+            if (opLtr === 'M' || opLtr === 'EQ' || opLtr === 'X' || opLtr === 'D' || opLtr === 'N' || opLtr === '=') lengthOnRef += opLen;
+            cigarArray.push({
+              len: opLen,
+              ltr: opLtr
+            });
+          }
+
+          return {
+            lengthOnRef: lengthOnRef,
+            array: cigarArray
+          };
+        }
+        /**
+         * Split the alignment record into blocks as specified in the cigarArray.  Each aligned block contains
+         * its portion of the read sequence and base quality strings.  A read sequence or base quality string
+         * of "*" indicates the value is not recorded.  In all other cases the length of the block sequence (block.seq)
+         * and quality string (block.qual) must == the block length.
+         *
+         * NOTE: Insertions are not yet treated // TODO
+         *
+         * @param record
+         * @param cigarArray
+         * @returns array of blocks
+         */
+
+
+        function makeBlocks(record, cigarArray) {
+          var blocks = [],
+              gaps,
+              insertions,
+              seqOffset = 0,
+              pos = record.start,
+              len = cigarArray.length,
+              gapType;
+
+          for (var i = 0; i < len; i++) {
+            var c = cigarArray[i];
+
+            switch (c.ltr) {
+              case 'H':
+                break;
+              // ignore hard clips
+
+              case 'P':
+                break;
+              // ignore pads
+
+              case 'S':
+                seqOffset += c.len;
+                gapType = 'S';
+                break;
+              // soft clip read bases
+
+              case 'N':
+              case 'D':
+                if (gaps === undefined) {
+                  gaps = [];
+                }
+
+                gaps.push({
+                  start: pos,
+                  len: c.len,
+                  type: c.ltr
+                });
+                pos += c.len;
+                break;
+
+              case 'I':
+                if (insertions === undefined) insertions = [];
+                insertions.push(new AlignmentBlock({
+                  start: pos,
+                  len: c.len,
+                  seqOffset: seqOffset
+                }));
+                seqOffset += c.len;
+                break;
+
+              case 'M':
+              case 'EQ':
+              case '=':
+              case 'X':
+                blocks.push(new AlignmentBlock({
+                  start: pos,
+                  len: c.len,
+                  seqOffset: seqOffset,
+                  gapType: gapType
+                }));
+                seqOffset += c.len;
+                pos += c.len;
+                break;
+            }
+          }
+
+          return {
+            blocks: blocks,
+            insertions: insertions,
+            gaps: gaps
+          };
+        }
+      }
+    };
+
+    Ga4ghAlignmentReader.prototype.readMetadata = function () {
+      return ga4ghGet({
+        url: this.url,
+        entity: "readgroupsets",
+        entityId: this.readGroupSetIds
+      });
+    };
+    /**
+     * Hardcoded hack to work around some non-compliant google datasets
+     *
+     * @param chrAliasTable
+     * @param datasetId
+     */
+
+
+    function populateChrAliasTable(chrAliasTable, datasetId) {
+      var i;
+
+      if ("461916304629" === datasetId || "337315832689" === datasetId) {
+        for (i = 1; i < 23; i++) {
+          chrAliasTable["chr" + i] = i;
+        }
+
+        chrAliasTable["chrX"] = "X";
+        chrAliasTable["chrY"] = "Y";
+        chrAliasTable["chrM"] = "MT";
+      }
+    }
+
+    /*
+     * The MIT License (MIT)
+     *
+     * Copyright (c) 2014 Broad Institute
+     *
+     * Permission is hereby granted, free of charge, to any person obtaining a copy
+     * of this software and associated documentation files (the "Software"), to deal
+     * in the Software without restriction, including without limitation the rights
+     * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+     * copies of the Software, and to permit persons to whom the Software is
+     * furnished to do so, subject to the following conditions:
+     *
+     * The above copyright notice and this permission notice shall be included in
+     * all copies or substantial portions of the Software.
+     *
+     *
+     * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+     * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+     * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+     * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+     * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+     * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+     * THE SOFTWARE.
+     */
+    const isString$1 = isString$6;
+
+    class BamSource {
+      constructor(config, browser) {
+        const genome = browser.genome;
+        this.config = config;
+        this.genome = genome;
+        this.alignmentContainer = undefined;
+
+        if (isString$1(config.url) && config.url.startsWith("data:")) {
+          if ("cram" === config.format) {
+            throw "CRAM data uris are not supported";
+          }
+
+          this.config.indexed = false;
+        }
+
+        if ("ga4gh" === config.sourceType) {
+          this.bamReader = new Ga4ghAlignmentReader(config, genome);
+        } else if ("pysam" === config.sourceType) {
+          this.bamReader = new BamWebserviceReader(config, genome);
+        } else if ("htsget" === config.sourceType) {
+          this.bamReader = new HtsgetBamReader(config, genome);
+        } else if ("shardedBam" === config.sourceType) {
+          this.bamReader = new ShardedBamReader(config, genome);
+        } else if ("cram" === config.format) {
+          this.bamReader = new CramReader(config, genome, browser);
+        } else {
+          if (this.config.indexed === false) {
+            this.bamReader = new BamReaderNonIndexed(config, genome);
+          } else {
+            this.bamReader = new BamReader(config, genome);
+          }
+        }
+
+        this.viewAsPairs = config.viewAsPairs;
+        this.showSoftClips = config.showSoftClips;
+      }
+
+      setViewAsPairs(bool) {
+
+        if (this.viewAsPairs !== bool) {
+          this.viewAsPairs = bool; // if (this.alignmentContainer) {
+          //     this.alignmentContainer.setViewAsPairs(bool);
+          // }
+        }
+      }
+
+      setShowSoftClips(bool) {
+        if (this.showSoftClips !== bool) {
+          this.showSoftClips = bool;
+        }
+      }
+
+      async getAlignments(chr, bpStart, bpEnd) {
+        const genome = this.genome;
+        const showSoftClips = this.showSoftClips;
+
+        if (this.alignmentContainer && this.alignmentContainer.contains(chr, bpStart, bpEnd)) {
+          return this.alignmentContainer;
+        } else {
+          const alignmentContainer = await this.bamReader.readAlignments(chr, bpStart, bpEnd);
+          let alignments = alignmentContainer.alignments;
+
+          if (!this.viewAsPairs) {
+            alignments = unpairAlignments([{
+              alignments: alignments
+            }]);
+          }
+
+          const hasAlignments = alignments.length > 0;
+          alignmentContainer.packedAlignmentRows = packAlignmentRows(alignments, alignmentContainer.start, alignmentContainer.end, showSoftClips);
+          alignmentContainer.alignments = undefined; // Don't need to hold onto these anymore
+
+          this.alignmentContainer = alignmentContainer;
+
+          if (hasAlignments) {
+            const sequence = await genome.sequence.getSequence(chr, alignmentContainer.start, alignmentContainer.end);
+
+            if (sequence) {
+              alignmentContainer.coverageMap.refSeq = sequence; // TODO -- fix this
+
+              alignmentContainer.sequence = sequence; // TODO -- fix this
+
+              return alignmentContainer;
+            } else {
+              console.error("No sequence for: " + chr + ":" + alignmentContainer.start + "-" + alignmentContainer.end);
+            }
+          }
+
+          return alignmentContainer;
+        }
+      }
+
+    }
+
+    /*
+     * The MIT License (MIT)
+     *
+     * Copyright (c) 2014 Broad Institute
+     *
+     * Permission is hereby granted, free of charge, to any person obtaining a copy
+     * of this software and associated documentation files (the "Software"), to deal
+     * in the Software without restriction, including without limitation the rights
+     * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+     * copies of the Software, and to permit persons to whom the Software is
+     * furnished to do so, subject to the following conditions:
+     *
+     * The above copyright notice and this permission notice shall be included in
+     * all copies or substantial portions of the Software.
+     *
+     *
+     * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+     * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+     * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+     * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+     * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+     * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+     * THE SOFTWARE.
+     */
+    const alignmentStartGap = 5;
+    const downsampleRowHeight = 5;
+    const DEFAULT_COVERAGE_TRACK_HEIGHT = 50;
+    const DEFAULT_TRACK_HEIGHT = 300;
+    const DEFAULT_ALIGNMENT_COLOR = "rgb(185, 185, 185)";
+    const DEFAULT_COVERAGE_COLOR = "rgb(150, 150, 150)";
+    const DEFAULT_CONNECTOR_COLOR = "rgb(200, 200, 200)";
+
+    class BAMTrack extends TrackBase {
+      constructor(config, browser) {
+        super(config, browser);
+      }
+
+      init(config) {
+        super.init(config);
+        this.type = "alignment";
+
+        if (config.alleleFreqThreshold === undefined) {
+          config.alleleFreqThreshold = 0.2;
+        }
+
+        this.featureSource = new BamSource(config, this.browser);
+        this.showCoverage = config.showCoverage === undefined ? true : config.showCoverage;
+        this.showAlignments = config.showAlignments === undefined ? true : config.showAlignments;
+        this.coverageTrack = new CoverageTrack(config, this);
+        this.alignmentTrack = new AlignmentTrack(config, this);
+        this.alignmentTrack.setTop(this.coverageTrack, this.showCoverage);
+        this.visibilityWindow = config.visibilityWindow || 30000;
+        this.viewAsPairs = config.viewAsPairs;
+        this.pairsSupported = config.pairsSupported !== false;
+        this.showSoftClips = config.showSoftClips;
+        this.showAllBases = config.showAllBases;
+        this.showMismatches = config.showMismatches !== false;
+        this.color = config.color;
+        this.coverageColor = config.coverageColor;
+        this.minFragmentLength = config.minFragmentLength; // Optional, might be undefined
+
+        this.maxFragmentLength = config.maxFragmentLength; // The sort object can be an array in the case of multi-locus view, however if multiple sort positions
+        // are present for a given reference frame the last one will take precedence
+
+        if (config.sort) {
+          if (Array.isArray(config.sort)) {
+            // Legacy support
+            this.assignSort(config.sort[0]);
+          } else {
+            this.assignSort(config.sort);
+          }
+        } // Invoke height setter last to allocated to coverage and alignment tracks
+
+
+        this.height = config.height !== undefined ? config.height : DEFAULT_TRACK_HEIGHT;
+      }
+
+      set height(h) {
+        this._height = h;
+
+        if (this.coverageTrack && this.showAlignments) {
+          this.alignmentTrack.height = this.showCoverage ? h - this.coverageTrack.height : h;
+        }
+      }
+
+      get height() {
+        return this._height;
+      }
+
+      sort(options) {
+        options = this.assignSort(options);
+
+        for (let vp of this.trackView.viewports) {
+          if (vp.containsPosition(options.chr, options.position)) {
+            const alignmentContainer = vp.getCachedFeatures();
+
+            if (alignmentContainer) {
+              sortAlignmentRows(options, alignmentContainer);
+              vp.repaint();
+            }
+          }
+        }
+      }
+      /**
+       * Fix syntax problems for sort options.
+       * @param options
+       */
+
+
+      assignSort(options) {
+        // convert old syntax
+        if (options.locus) {
+          const range = parseLocusString$1(options.locus);
+          options.chr = range.chr;
+          options.position = range.start;
+        } else {
+          options.position--;
+        }
+
+        options.direction = options.direction === "ASC" || options.direction === true; // chr aliasing
+
+        options.chr = this.browser.genome.getChromosomeName(options.chr);
+        this.sortObject = options;
+        return this.sortObject;
+      }
+
+      async getFeatures(chr, bpStart, bpEnd, bpPerPixel, viewport) {
+        const alignmentContainer = await this.featureSource.getAlignments(chr, bpStart, bpEnd);
+
+        if (alignmentContainer.alignments && alignmentContainer.alignments.length > 99) {
+          if (undefined === this.minFragmentLength) {
+            this.minFragmentLength = alignmentContainer.pairedEndStats.lowerFragmentLength;
+          }
+
+          if (undefined === this.maxFragmentLength) {
+            this.maxFragmentLength = alignmentContainer.pairedEndStats.upperFragmentLength;
+          }
+        }
+
+        const sort = this.sortObject;
+
+        if (sort) {
+          if (sort.chr === chr && sort.position >= bpStart && sort.position <= bpEnd) {
+            sortAlignmentRows(sort, alignmentContainer);
+          }
+        }
+
+        return alignmentContainer;
+      }
+      /**
+       * Compute the pixel height required to display all content.  This is not the same as the viewport height
+       * (track.height) which might include a scrollbar.
+       *
+       * @param alignmentContainer
+       * @returns {number}
+       */
+
+
+      computePixelHeight(alignmentContainer) {
+        return (this.showCoverage ? this.coverageTrack.height : 0) + (this.showAlignments ? this.alignmentTrack.computePixelHeight(alignmentContainer) : 0) + 15;
+      }
+
+      draw(options) {
+        IGVGraphics.fillRect(options.context, 0, options.pixelTop, options.pixelWidth, options.pixelHeight, {
+          'fillStyle': "rgb(255, 255, 255)"
+        });
+
+        if (true === this.showCoverage && this.coverageTrack.height > 0) {
+          this.trackView.axisCanvas.style.display = 'block';
+          this.coverageTrack.draw(options);
+        } else {
+          this.trackView.axisCanvas.style.display = 'none';
+        }
+
+        if (true === this.showAlignments) {
+          this.alignmentTrack.setTop(this.coverageTrack, this.showCoverage);
+          this.alignmentTrack.draw(options);
+        }
+      }
+
+      paintAxis(ctx, pixelWidth, pixelHeight) {
+        this.coverageTrack.paintAxis(ctx, pixelWidth, this.coverageTrack.height); // if (this.browser.isMultiLocusMode()) {
+        //     ctx.clearRect(0, 0, pixelWidth, pixelHeight);
+        // } else {
+        //     this.coverageTrack.paintAxis(ctx, pixelWidth, this.coverageTrack.height);
+        // }
+      }
+
+      contextMenuItemList(config) {
+        return this.alignmentTrack.contextMenuItemList(config);
+      }
+
+      popupData(config) {
+        if (true === this.showCoverage && config.y >= this.coverageTrack.top && config.y < this.coverageTrack.height) {
+          return this.coverageTrack.popupData(config);
+        } else {
+          return this.alignmentTrack.popupData(config);
+        }
+      }
+
+      menuItemList() {
+        // Start with overage track items
+        let menuItems = ["<hr/>"];
+        menuItems = menuItems.concat(MenuUtils.numericDataMenuItems(this.trackView)); // Color by items
+
+        const $e = $('<div class="igv-track-menu-category igv-track-menu-border-top">');
+        $e.text('Color by:');
+        menuItems.push({
+          name: undefined,
+          object: $e,
+          click: undefined,
+          init: undefined
+        });
+        const colorByMenuItems = [{
+          key: 'strand',
+          label: 'read strand'
+        }];
+
+        if (this.alignmentTrack.hasPairs) {
+          colorByMenuItems.push({
+            key: 'firstOfPairStrand',
+            label: 'first-of-pair strand'
+          });
+          colorByMenuItems.push({
+            key: 'pairOrientation',
+            label: 'pair orientation'
+          });
+          colorByMenuItems.push({
+            key: 'fragmentLength',
+            label: 'insert size (TLEN)'
+          });
+        }
+
+        const tagLabel = 'tag' + (this.alignmentTrack.colorByTag ? ' (' + this.alignmentTrack.colorByTag + ')' : '');
+        colorByMenuItems.push({
+          key: 'tag',
+          label: tagLabel
+        });
+
+        for (let item of colorByMenuItems) {
+          const selected = this.alignmentTrack.colorBy === item.key;
+          menuItems.push(this.colorByCB(item, selected));
+        } // Show coverage / alignment options
+
+
+        const adjustTrackHeight = () => {
+          if (!this.autoHeight) {
+            const h = 15 + (this.showCoverage ? this.coverageTrack.height : 0) + (this.showAlignments ? this.alignmentTrack.height : 0);
+            this.trackView.setTrackHeight(h);
+          }
+        };
+
+        menuItems.push({
+          object: $('<div class="igv-track-menu-border-top">')
+        });
+        menuItems.push({
+          object: createCheckbox$1("Show Coverage", this.showCoverage),
+          click: () => {
+            this.showCoverage = !this.showCoverage;
+            adjustTrackHeight();
+            this.trackView.checkContentHeight();
+            this.trackView.repaintViews();
+          }
+        });
+        menuItems.push({
+          object: createCheckbox$1("Show Alignments", this.showAlignments),
+          click: () => {
+            this.showAlignments = !this.showAlignments;
+            adjustTrackHeight();
+            this.trackView.checkContentHeight();
+            this.trackView.repaintViews();
+          }
+        }); // Show all bases
+
+        menuItems.push({
+          object: $('<div class="igv-track-menu-border-top">')
+        });
+        menuItems.push({
+          object: createCheckbox$1("Show all bases", this.showAllBases),
+          click: () => {
+            this.showAllBases = !this.showAllBases;
+            this.config.showAllBases = this.showAllBases;
+            this.trackView.repaintViews();
+          }
+        }); // Soft clips
+
+        menuItems.push({
+          object: createCheckbox$1("Show soft clips", this.showSoftClips),
+          click: () => {
+            this.showSoftClips = !this.showSoftClips;
+            this.config.showSoftClips = this.showSoftClips;
+            this.featureSource.setShowSoftClips(this.showSoftClips);
+            const alignmentContainers = this.getCachedAlignmentContainers();
+
+            for (let ac of alignmentContainers) {
+              ac.setShowSoftClips(this.showSoftClips);
+            }
+
+            this.trackView.repaintViews();
+          }
+        }); // View as pairs
+
+        if (this.pairsSupported && this.alignmentTrack.hasPairs) {
+          menuItems.push({
+            object: $('<div class="igv-track-menu-border-top">')
+          });
+          menuItems.push({
+            object: createCheckbox$1("View as pairs", this.viewAsPairs),
+            click: () => {
+              this.viewAsPairs = !this.viewAsPairs;
+              this.config.viewAsPairs = this.viewAsPairs;
+              this.featureSource.setViewAsPairs(this.viewAsPairs);
+              const alignmentContainers = this.getCachedAlignmentContainers();
+
+              for (let ac of alignmentContainers) {
+                ac.setViewAsPairs(this.viewAsPairs);
+              }
+
+              this.trackView.repaintViews();
+            }
+          });
+        } // Display mode
+
+
+        const $displayModeLabel = $('<div class="igv-track-menu-category igv-track-menu-border-top">');
+        $displayModeLabel.text('Display mode:');
+        menuItems.push({
+          name: undefined,
+          object: $displayModeLabel,
+          click: undefined,
+          init: undefined
+        });
+        menuItems.push({
+          object: createCheckbox$1("expand", this.alignmentTrack.displayMode === "EXPANDED"),
+          click: () => {
+            this.alignmentTrack.displayMode = "EXPANDED";
+            this.config.displayMode = "EXPANDED";
+            this.trackView.checkContentHeight();
+            this.trackView.repaintViews();
+          }
+        });
+        menuItems.push({
+          object: createCheckbox$1("squish", this.alignmentTrack.displayMode === "SQUISHED"),
+          click: () => {
+            this.alignmentTrack.displayMode = "SQUISHED";
+            this.config.displayMode = "SQUISHED";
+            this.trackView.checkContentHeight();
+            this.trackView.repaintViews();
+          }
+        });
+        return menuItems;
+      }
+      /**
+       * Create a "color by" checkbox menu item, optionally initially checked
+       * @param menuItem
+       * @param showCheck
+       * @returns {{init: undefined, name: undefined, click: clickHandler, object: (jQuery|HTMLElement|jQuery.fn.init)}}
+       */
+
+
+      colorByCB(menuItem, showCheck) {
+        const $e = createCheckbox$1(menuItem.label, showCheck);
+
+        const clickHandler = ev => {
+          if (menuItem.key === this.alignmentTrack.colorBy) {
+            this.alignmentTrack.colorBy = 'none';
+            this.config.colorBy = 'none';
+            this.trackView.repaintViews();
+          } else if ('tag' === menuItem.key) {
+            this.browser.inputDialog.present({
+              label: 'Tag Name',
+              value: this.alignmentTrack.colorByTag ? this.alignmentTrack.colorByTag : '',
+              callback: tag => {
+                this.alignmentTrack.colorBy = 'tag';
+                this.config.colorBy = 'tag';
+
+                if (tag !== this.alignmentTrack.colorByTag) {
+                  this.alignmentTrack.colorByTag = tag;
+                  this.config.colorByTag = tag;
+                  this.alignmentTrack.tagColors = new PaletteColorTable("Set1");
+                  $('#color-by-tag').text(self.alignmentTrack.colorByTag);
+                }
+
+                this.trackView.repaintViews();
+              }
+            }, ev);
+          } else {
+            this.alignmentTrack.colorBy = menuItem.key;
+            this.config.colorBy = menuItem.key;
+            this.trackView.repaintViews();
+          }
+        };
+
+        return {
+          name: undefined,
+          object: $e,
+          click: clickHandler,
+          init: undefined
+        };
+      }
+      /**
+       * Called when the track is removed.  Do any needed cleanup here
+       */
+
+
+      dispose() {
+        this.trackView = undefined;
+      }
+      /**
+       * Return the current state of the track.  Used to create sessions and bookmarks.
+       *
+       * @returns {*|{}}
+       */
+
+
+      getState() {
+        const config = super.getState();
+
+        if (this.sortObject) {
+          config.sort = {
+            chr: this.sortObject.chr,
+            position: this.sortObject.position + 1,
+            option: this.sortObject.option,
+            direction: this.sortObject.direction ? "ASC" : "DESC"
+          };
+        }
+
+        return config;
+      }
+
+      getCachedAlignmentContainers() {
+        return this.trackView.viewports.map(vp => vp.getCachedFeatures());
+      }
+
+      get dataRange() {
+        return this.coverageTrack.dataRange;
+      }
+
+      set dataRange(dataRange) {
+        this.coverageTrack.dataRange = dataRange;
+      }
+
+      get logScale() {
+        return this.coverageTrack.logScale;
+      }
+
+      set logScale(logScale) {
+        this.coverageTrack.logScale = logScale;
+      }
+
+      get autoscale() {
+        return this.coverageTrack.autoscale;
+      }
+
+      set autoscale(autoscale) {
+        this.coverageTrack.autoscale = autoscale;
+      }
+
+    }
+
+    class CoverageTrack {
+      constructor(config, parent) {
+        this.parent = parent;
+        this.featureSource = parent.featureSource;
+        this.height = config.coverageTrackHeight !== undefined ? config.coverageTrackHeight : DEFAULT_COVERAGE_TRACK_HEIGHT;
+        this.paintAxis = paintAxis;
+        this.top = 0;
+        this.autoscale = config.autoscale || config.max === undefined;
+
+        if (!this.autoscale) {
+          this.dataRange = {
+            min: config.min || 0,
+            max: config.max
+          };
+        }
+      }
+
+      draw(options) {
+        const pixelTop = options.pixelTop;
+        pixelTop + options.pixelHeight;
+        const nucleotideColors = this.parent.browser.nucleotideColors;
+
+        if (pixelTop > this.height) {
+          return; //scrolled out of view
+        }
+
+        const ctx = options.context;
+        const alignmentContainer = options.features;
+        const coverageMap = alignmentContainer.coverageMap;
+        let sequence;
+
+        if (coverageMap.refSeq) {
+          sequence = coverageMap.refSeq.toUpperCase();
+        }
+
+        const bpPerPixel = options.bpPerPixel;
+        const bpStart = options.bpStart;
+        const pixelWidth = options.pixelWidth;
+        const bpEnd = bpStart + pixelWidth * bpPerPixel + 1; // paint for all coverage buckets
+        // If alignment track color is != default, use it
+
+        let color = this.parent.coverageColor || DEFAULT_COVERAGE_COLOR;
+
+        if (this.parent.color !== undefined) {
+          color = IGVColor.darkenLighten(this.parent.color, -35);
+        }
+
+        IGVGraphics.setProperties(ctx, {
+          fillStyle: color,
+          strokeStyle: color
+        });
+        const w = Math.max(1, Math.ceil(1.0 / bpPerPixel));
+
+        for (let i = 0, len = coverageMap.coverage.length; i < len; i++) {
+          const bp = coverageMap.bpStart + i;
+          if (bp < bpStart) continue;
+          if (bp > bpEnd) break;
+          const item = coverageMap.coverage[i];
+          if (!item) continue;
+          const h = Math.round(item.total / this.dataRange.max * this.height);
+          const y = this.height - h;
+          const x = Math.floor((bp - bpStart) / bpPerPixel); // IGVGraphics.setProperties(ctx, {fillStyle: "rgba(0, 200, 0, 0.25)", strokeStyle: "rgba(0, 200, 0, 0.25)" });
+
+          IGVGraphics.fillRect(ctx, x, y, w, h);
+        } // coverage mismatch coloring -- don't try to do this in above loop, color bar will be overwritten when w<1
+
+
+        if (sequence) {
+          for (let i = 0, len = coverageMap.coverage.length; i < len; i++) {
+            const bp = coverageMap.bpStart + i;
+            if (bp < bpStart) continue;
+            if (bp > bpEnd) break;
+            const item = coverageMap.coverage[i];
+            if (!item) continue;
+            const h = item.total / this.dataRange.max * this.height;
+            let y = this.height - h;
+            const x = Math.floor((bp - bpStart) / bpPerPixel);
+            const refBase = sequence[i];
+
+            if (item.isMismatch(refBase)) {
+              IGVGraphics.setProperties(ctx, {
+                fillStyle: nucleotideColors[refBase]
+              });
+              IGVGraphics.fillRect(ctx, x, y, w, h);
+              let accumulatedHeight = 0.0;
+
+              for (let nucleotide of ["A", "C", "T", "G"]) {
+                const count = item["pos" + nucleotide] + item["neg" + nucleotide]; // non-logoritmic
+
+                const hh = count / this.dataRange.max * this.height;
+                y = this.height - hh - accumulatedHeight;
+                accumulatedHeight += hh;
+                IGVGraphics.setProperties(ctx, {
+                  fillStyle: nucleotideColors[nucleotide]
+                });
+                IGVGraphics.fillRect(ctx, x, y, w, hh);
+              }
+            }
+          }
+        }
+      }
+
+      popupData(config) {
+        let features = config.viewport.getCachedFeatures();
+        if (!features || features.length === 0) return;
+        let genomicLocation = Math.floor(config.genomicLocation),
+            referenceFrame = config.viewport.referenceFrame,
+            coverageMap = features.coverageMap,
+            nameValues = [],
+            coverageMapIndex = Math.floor(genomicLocation - coverageMap.bpStart),
+            coverage = coverageMap.coverage[coverageMapIndex];
+
+        if (coverage) {
+          nameValues.push(referenceFrame.chr + ":" + numberFormatter$1(1 + genomicLocation));
+          nameValues.push({
+            name: 'Total Count',
+            value: coverage.total
+          }); // A
+
+          let tmp = coverage.posA + coverage.negA;
+          if (tmp > 0) tmp = tmp.toString() + " (" + Math.round(tmp / coverage.total * 100.0) + "%, " + coverage.posA + "+, " + coverage.negA + "- )";
+          nameValues.push({
+            name: 'A',
+            value: tmp
+          }); // C
+
+          tmp = coverage.posC + coverage.negC;
+          if (tmp > 0) tmp = tmp.toString() + " (" + Math.round(tmp / coverage.total * 100.0) + "%, " + coverage.posC + "+, " + coverage.negC + "- )";
+          nameValues.push({
+            name: 'C',
+            value: tmp
+          }); // G
+
+          tmp = coverage.posG + coverage.negG;
+          if (tmp > 0) tmp = tmp.toString() + " (" + Math.round(tmp / coverage.total * 100.0) + "%, " + coverage.posG + "+, " + coverage.negG + "- )";
+          nameValues.push({
+            name: 'G',
+            value: tmp
+          }); // T
+
+          tmp = coverage.posT + coverage.negT;
+          if (tmp > 0) tmp = tmp.toString() + " (" + Math.round(tmp / coverage.total * 100.0) + "%, " + coverage.posT + "+, " + coverage.negT + "- )";
+          nameValues.push({
+            name: 'T',
+            value: tmp
+          }); // N
+
+          tmp = coverage.posN + coverage.negN;
+          if (tmp > 0) tmp = tmp.toString() + " (" + Math.round(tmp / coverage.total * 100.0) + "%, " + coverage.posN + "+, " + coverage.negN + "- )";
+          nameValues.push({
+            name: 'N',
+            value: tmp
+          });
+          nameValues.push('<HR/>');
+          nameValues.push({
+            name: 'DEL',
+            value: coverage.del.toString()
+          });
+          nameValues.push({
+            name: 'INS',
+            value: coverage.ins.toString()
+          });
+        }
+
+        return nameValues;
+      }
+
+    }
+
+    class AlignmentTrack {
+      constructor(config, parent) {
+        this.parent = parent;
+        this.browser = parent.browser;
+        this.featureSource = parent.featureSource;
+        this.top = 0 === config.coverageTrackHeight ? 0 : config.coverageTrackHeight + 5;
+        this.displayMode = config.displayMode || "EXPANDED";
+        this.alignmentRowHeight = config.alignmentRowHeight || 14;
+        this.squishedRowHeight = config.squishedRowHeight || 3;
+        this.negStrandColor = config.negStrandColor || "rgba(150, 150, 230, 0.75)";
+        this.posStrandColor = config.posStrandColor || "rgba(230, 150, 150, 0.75)";
+        this.insertionColor = config.insertionColor || "rgb(138, 94, 161)";
+        this.deletionColor = config.deletionColor || "black";
+        this.skippedColor = config.skippedColor || "rgb(150, 170, 170)";
+        this.pairConnectorColor = config.pairConnectorColor;
+        this.smallFragmentLengthColor = config.smallFragmentLengthColor || "rgb(0, 0, 150)";
+        this.largeFragmentLengthColor = config.largeFragmentLengthColor || "rgb(200, 0, 0)";
+        this.pairOrientation = config.pairOrienation || 'fr';
+        this.pairColors = {};
+        this.pairColors["RL"] = config.rlColor || "rgb(0, 150, 0)";
+        this.pairColors["RR"] = config.rrColor || "rgb(20, 50, 200)";
+        this.pairColors["LL"] = config.llColor || "rgb(0, 150, 150)";
+        this.colorBy = config.colorBy || "pairOrientation";
+        this.colorByTag = config.colorByTag ? config.colorByTag.toUpperCase() : undefined;
+        this.bamColorTag = config.bamColorTag === undefined ? "YC" : config.bamColorTag;
+        this.hideSmallIndels = config.hideSmallIndels;
+        this.indelSizeThreshold = config.indelSizeThreshold || 1;
+        this.hasPairs = false; // Until proven otherwise
+      }
+
+      setTop(coverageTrack, showCoverage) {
+        this.top = 0 === coverageTrack.height || false === showCoverage ? 0 : 5 + coverageTrack.height;
+      }
+      /**
+       * Compute the pixel height required to display all content.
+       *
+       * @param alignmentContainer
+       * @returns {number|*}
+       */
+
+
+      computePixelHeight(alignmentContainer) {
+        if (alignmentContainer.packedAlignmentRows) {
+          const h = alignmentContainer.hasDownsampledIntervals() ? downsampleRowHeight + alignmentStartGap : 0;
+          const alignmentRowHeight = this.displayMode === "SQUISHED" ? this.squishedRowHeight : this.alignmentRowHeight;
+          return h + alignmentRowHeight * alignmentContainer.packedAlignmentRows.length + 5;
+        } else {
+          return 0;
+        }
+      }
+
+      draw(options) {
+        const alignmentContainer = options.features;
+        const ctx = options.context;
+        const bpPerPixel = options.bpPerPixel;
+        const bpStart = options.bpStart;
+        const pixelWidth = options.pixelWidth;
+        const bpEnd = bpStart + pixelWidth * bpPerPixel + 1;
+        const packedAlignmentRows = alignmentContainer.packedAlignmentRows;
+        const showSoftClips = this.parent.showSoftClips;
+        const showAllBases = this.parent.showAllBases;
+        const nucleotideColors = this.browser.nucleotideColors;
+        ctx.save();
+        let referenceSequence = alignmentContainer.sequence;
+
+        if (referenceSequence) {
+          referenceSequence = referenceSequence.toUpperCase();
+        }
+
+        let alignmentRowYInset = 0;
+        let pixelTop = options.pixelTop;
+
+        if (this.top) {
+          ctx.translate(0, this.top);
+        }
+
+        const pixelBottom = pixelTop + options.pixelHeight;
+
+        if (alignmentContainer.hasDownsampledIntervals()) {
+          alignmentRowYInset = downsampleRowHeight + alignmentStartGap;
+          alignmentContainer.downsampledIntervals.forEach(function (interval) {
+            var xBlockStart = (interval.start - bpStart) / bpPerPixel,
+                xBlockEnd = (interval.end - bpStart) / bpPerPixel;
+
+            if (xBlockEnd - xBlockStart > 5) {
+              xBlockStart += 1;
+              xBlockEnd -= 1;
+            }
+
+            IGVGraphics.fillRect(ctx, xBlockStart, 2, xBlockEnd - xBlockStart, downsampleRowHeight - 2, {
+              fillStyle: "black"
+            });
+          });
+        } else {
+          alignmentRowYInset = 0;
+        } // Transient variable -- rewritten on every draw, used for click object selection
+
+
+        this.alignmentsYOffset = alignmentRowYInset;
+        const alignmentRowHeight = this.displayMode === "SQUISHED" ? this.squishedRowHeight : this.alignmentRowHeight;
+
+        if (packedAlignmentRows) {
+          const nRows = packedAlignmentRows.length;
+
+          for (let rowIndex = 0; rowIndex < nRows; rowIndex++) {
+            const alignmentRow = packedAlignmentRows[rowIndex];
+            const alignmentY = alignmentRowYInset + alignmentRowHeight * rowIndex;
+            const alignmentHeight = alignmentRowHeight <= 4 ? alignmentRowHeight : alignmentRowHeight - 2;
+
+            if (alignmentY > pixelBottom) {
+              break;
+            } else if (alignmentY + alignmentHeight < pixelTop) {
+              continue;
+            }
+
+            for (let alignment of alignmentRow.alignments) {
+              this.hasPairs = this.hasPairs || alignment.isPaired();
+              if (alignment.start + alignment.lengthOnRef < bpStart) continue;
+              if (alignment.start > bpEnd) break;
+
+              if (true === alignment.hidden) {
+                continue;
+              }
+
+              if (alignment instanceof PairedAlignment) {
+                drawPairConnector.call(this, alignment, alignmentY, alignmentHeight);
+                drawSingleAlignment.call(this, alignment.firstAlignment, alignmentY, alignmentHeight);
+
+                if (alignment.secondAlignment) {
+                  drawSingleAlignment.call(this, alignment.secondAlignment, alignmentY, alignmentHeight);
+                }
+              } else {
+                drawSingleAlignment.call(this, alignment, alignmentY, alignmentHeight);
+              }
+            }
+          }
+        }
+
+        ctx.restore(); // alignment is a PairedAlignment
+
+        function drawPairConnector(alignment, yRect, alignmentHeight) {
+          var connectorColor = this.getConnectorColor(alignment.firstAlignment),
+              xBlockStart = (alignment.connectingStart - bpStart) / bpPerPixel,
+              xBlockEnd = (alignment.connectingEnd - bpStart) / bpPerPixel,
+              yStrokedLine = yRect + alignmentHeight / 2;
+
+          if (alignment.connectingEnd < bpStart || alignment.connectingStart > bpEnd) {
+            return;
+          }
+
+          if (alignment.mq <= 0) {
+            connectorColor = IGVColor.addAlpha(connectorColor, 0.15);
+          }
+
+          IGVGraphics.setProperties(ctx, {
+            fillStyle: connectorColor,
+            strokeStyle: connectorColor
+          });
+          IGVGraphics.strokeLine(ctx, xBlockStart, yStrokedLine, xBlockEnd, yStrokedLine);
+        }
+
+        function drawSingleAlignment(alignment, yRect, alignmentHeight) {
+          if (alignment.start + alignment.lengthOnRef < bpStart || alignment.start > bpEnd) {
+            return;
+          }
+
+          const blocks = showSoftClips ? alignment.blocks : alignment.blocks.filter(b => 'S' !== b.type);
+          let alignmentColor = this.getAlignmentColor(alignment);
+          const outlineColor = alignmentColor;
+
+          if (alignment.mq <= 0) {
+            alignmentColor = IGVColor.addAlpha(alignmentColor, 0.15);
+          }
+
+          IGVGraphics.setProperties(ctx, {
+            fillStyle: alignmentColor,
+            strokeStyle: outlineColor
+          });
+
+          for (let b = 0; b < blocks.length; b++) {
+            // Can't use forEach here -- we need ability to break
+            const block = blocks[b]; // Somewhat complex test, neccessary to insure gaps are drawn.
+            // If this is not the last block, and the next block starts before the orign (off screen to left) then skip.
+
+            if (b !== blocks.length - 1 && blocks[b + 1].start < bpStart) continue;
+            drawBlock.call(this, block, b);
+
+            if (block.start + block.len > bpEnd) {
+              // Do this after drawBlock to insure gaps are drawn
+              break;
+            }
+          }
+
+          if (alignment.insertions) {
+            let lastXBlockStart = -1;
+
+            for (let insertionBlock of alignment.insertions) {
+              if (this.hideSmallIndels && insertionBlock.len <= this.indelSizeThreshold) {
+                continue;
+              }
+
+              if (insertionBlock.start < bpStart) {
+                continue;
+              }
+
+              if (insertionBlock.start > bpEnd) {
+                break;
+              }
+
+              const refOffset = insertionBlock.start - bpStart;
+              const xBlockStart = refOffset / bpPerPixel - 1;
+
+              if (xBlockStart - lastXBlockStart > 2) {
+                const widthBlock = 3;
+                IGVGraphics.fillRect(ctx, xBlockStart, yRect - 1, widthBlock, alignmentHeight + 2, {
+                  fillStyle: this.insertionColor
+                });
+                lastXBlockStart = xBlockStart;
+              }
+            }
+          }
+
+          if (alignment.gaps) {
+            const yStrokedLine = yRect + alignmentHeight / 2;
+
+            for (let gap of alignment.gaps) {
+              const sPixel = (gap.start - bpStart) / bpPerPixel;
+              const ePixel = (gap.start + gap.len - bpStart) / bpPerPixel;
+              const color = "D" === gap.type ? this.deletionColor : this.skippedColor;
+              IGVGraphics.strokeLine(ctx, sPixel, yStrokedLine, ePixel, yStrokedLine, {
+                strokeStyle: color
+              });
+            }
+          }
+
+          function drawBlock(block, b) {
+            const offsetBP = block.start - alignmentContainer.start;
+            const blockStartPixel = (block.start - bpStart) / bpPerPixel;
+            const blockEndPixel = (block.start + block.len - bpStart) / bpPerPixel;
+            const blockWidthPixel = Math.max(1, blockEndPixel - blockStartPixel);
+            const arrowHeadWidthPixel = alignmentRowHeight / 2.0;
+            const isSoftClip = 'S' === block.type;
+            const strokeOutline = alignment.mq <= 0 || this.highlightedAlignmentReadNamed === alignment.readName || isSoftClip;
+            let blockOutlineColor = outlineColor;
+            if (this.highlightedAlignmentReadNamed === alignment.readName) blockOutlineColor = 'red';else if (isSoftClip) blockOutlineColor = 'rgb(50,50,50)';
+            const lastBlockPositiveStrand = true === alignment.strand && b === blocks.length - 1;
+            const lastBlockReverseStrand = false === alignment.strand && b === 0;
+            const lastBlock = lastBlockPositiveStrand | lastBlockReverseStrand;
+
+            if (lastBlock) {
+              let xListPixel;
+              let yListPixel;
+
+              if (lastBlockPositiveStrand) {
+                xListPixel = [blockStartPixel, blockEndPixel, blockEndPixel + arrowHeadWidthPixel, blockEndPixel, blockStartPixel, blockStartPixel];
+                yListPixel = [yRect, yRect, yRect + alignmentHeight / 2.0, yRect + alignmentHeight, yRect + alignmentHeight, yRect];
+              } // Last block on - strand ?
+              else if (lastBlockReverseStrand) {
+                xListPixel = [blockEndPixel, blockStartPixel, blockStartPixel - arrowHeadWidthPixel, blockStartPixel, blockEndPixel, blockEndPixel];
+                yListPixel = [yRect, yRect, yRect + alignmentHeight / 2.0, yRect + alignmentHeight, yRect + alignmentHeight, yRect];
+              }
+
+              IGVGraphics.fillPolygon(ctx, xListPixel, yListPixel, {
+                fillStyle: alignmentColor
+              });
+
+              if (strokeOutline) {
+                IGVGraphics.strokePolygon(ctx, xListPixel, yListPixel, {
+                  strokeStyle: blockOutlineColor
+                });
+              }
+            } // Internal block
+            else {
+              IGVGraphics.fillRect(ctx, blockStartPixel, yRect, blockWidthPixel, alignmentHeight, {
+                fillStyle: alignmentColor
+              });
+
+              if (strokeOutline) {
+                ctx.save();
+                ctx.strokeStyle = blockOutlineColor;
+                ctx.strokeRect(blockStartPixel, yRect, blockWidthPixel, alignmentHeight);
+                ctx.restore();
+              }
+            } // Mismatch coloring
+
+
+            if (this.parent.showMismatches && (isSoftClip || showAllBases || referenceSequence && alignment.seq && alignment.seq !== "*")) {
+              const seq = alignment.seq ? alignment.seq.toUpperCase() : undefined;
+              const qual = alignment.qual;
+              const seqOffset = block.seqOffset;
+
+              for (let i = 0, len = block.len; i < len; i++) {
+                if (offsetBP + i < 0) continue;
+                let readChar = seq ? seq.charAt(seqOffset + i) : '';
+                const refChar = referenceSequence.charAt(offsetBP + i);
+
+                if (readChar === "=") {
+                  readChar = refChar;
+                }
+
+                if (readChar === "X" || refChar !== readChar || isSoftClip || showAllBases) {
+                  let baseColor;
+
+                  if (!isSoftClip && qual !== undefined && qual.length > seqOffset + i) {
+                    const readQual = qual[seqOffset + i];
+                    baseColor = shadedBaseColor(readQual, nucleotideColors[readChar]);
+                  } else {
+                    baseColor = nucleotideColors[readChar];
+                  }
+
+                  if (baseColor) {
+                    const xPixel = (block.start + i - bpStart) / bpPerPixel;
+                    const widthPixel = Math.max(1, 1 / bpPerPixel);
+                    renderBlockOrReadChar(ctx, bpPerPixel, {
+                      x: xPixel,
+                      y: yRect,
+                      width: widthPixel,
+                      height: alignmentHeight
+                    }, baseColor, readChar);
+                  }
+                }
+              }
+            }
+          }
+
+          function renderBlockOrReadChar(context, bpp, bbox, color, char) {
+            var threshold, center;
+            threshold = 1.0 / 10.0;
+
+            if (bpp <= threshold && bbox.height >= 8) {
+              // render letter
+              const fontHeight = Math.min(10, bbox.height);
+              context.font = '' + fontHeight + 'px sans-serif';
+              center = bbox.x + bbox.width / 2.0;
+              IGVGraphics.strokeText(context, char, center - context.measureText(char).width / 2, fontHeight - 1 + bbox.y, {
+                strokeStyle: color
+              });
+            } else {
+              // render colored block
+              IGVGraphics.fillRect(context, bbox.x, bbox.y, bbox.width, bbox.height, {
+                fillStyle: color
+              });
+            }
+          }
+        }
+      }
+
+      popupData(config) {
+        const clickedObject = this.getClickedObject(config.viewport, config.y, config.genomicLocation);
+        return clickedObject ? clickedObject.popupData(config.genomicLocation) : undefined;
+      }
+
+      contextMenuItemList(clickState) {
+        const viewport = clickState.viewport;
+        const list = [];
+
+        const sortByOption = option => {
+          const cs = this.parent.sortObject;
+          const direction = cs && cs.position === Math.floor(clickState.genomicLocation) ? !cs.direction : true;
+          const newSortObject = {
+            chr: viewport.referenceFrame.chr,
+            position: Math.floor(clickState.genomicLocation),
+            option: option,
+            direction: direction
+          };
+          this.parent.sortObject = newSortObject;
+          sortAlignmentRows(newSortObject, viewport.getCachedFeatures());
+          viewport.repaint();
+        };
+
+        list.push('<b>Sort by...</b>');
+        list.push({
+          label: '&nbsp; base',
+          click: () => sortByOption("BASE")
+        });
+        list.push({
+          label: '&nbsp; read strand',
+          click: () => sortByOption("STRAND")
+        });
+        list.push({
+          label: '&nbsp; insert size',
+          click: () => sortByOption("INSERT_SIZE")
+        });
+        list.push({
+          label: '&nbsp; gap size',
+          click: () => sortByOption("GAP_SIZE")
+        });
+        list.push({
+          label: '&nbsp; chromosome of mate',
+          click: () => sortByOption("MATE_CHR")
+        });
+        list.push({
+          label: '&nbsp; mapping quality',
+          click: () => sortByOption("MQ")
+        });
+        list.push({
+          label: '&nbsp; read name',
+          click: () => sortByOption("READ_NAME")
+        });
+        list.push({
+          label: '&nbsp; tag',
+          click: () => {
+            const cs = this.parent.sortObject;
+            const direction = cs && cs.position === Math.floor(clickState.genomicLocation) ? !cs.direction : true;
+            const config = {
+              label: 'Tag Name',
+              value: this.sortByTag ? this.sortByTag : '',
+              callback: tag => {
+                if (tag) {
+                  const newSortObject = {
+                    chr: viewport.referenceFrame.chr,
+                    position: Math.floor(clickState.genomicLocation),
+                    option: "TAG",
+                    tag: tag,
+                    direction: direction
+                  };
+                  this.sortByTag = tag;
+                  this.parent.sortObject = newSortObject;
+                  sortAlignmentRows(newSortObject, viewport.getCachedFeatures());
+                  viewport.repaint();
+                }
+              }
+            };
+            this.browser.inputDialog.present(config, clickState.event);
+          }
+        });
+        list.push('<hr/>');
+        const clickedObject = this.getClickedObject(viewport, clickState.y, clickState.genomicLocation);
+
+        if (clickedObject) {
+          const showSoftClips = this.parent.showSoftClips;
+          const clickedAlignment = typeof clickedObject.alignmentContaining === 'function' ? clickedObject.alignmentContaining(clickState.genomicLocation, showSoftClips) : clickedObject;
+
+          if (clickedAlignment.isPaired() && clickedAlignment.isMateMapped()) {
+            list.push({
+              label: 'View mate in split screen',
+              click: () => {
+                if (clickedAlignment.mate) {
+                  const referenceFrame = clickState.viewport.referenceFrame;
+
+                  if (this.browser.genome.getChromosome(clickedAlignment.mate.chr)) {
+                    this.highlightedAlignmentReadNamed = clickedAlignment.readName;
+                    this.browser.presentSplitScreenMultiLocusPanel(clickedAlignment, referenceFrame);
+                  } else {
+                    Alert.presentAlert(`Reference does not contain chromosome: ${clickedAlignment.mate.chr}`);
+                  }
+                }
+              },
+              init: undefined
+            });
+          }
+
+          list.push({
+            label: 'View read sequence',
+            click: () => {
+              const alignment = clickedAlignment;
+              if (!alignment) return;
+              const seqstring = alignment.seq; //.map(b => String.fromCharCode(b)).join("");
+
+              if (!seqstring || "*" === seqstring) {
+                Alert.presentAlert("Read sequence: *");
+              } else {
+                Alert.presentAlert(seqstring);
+              }
+            }
+          });
+          list.push('<hr/>');
+        }
+
+        return list;
+      }
+
+      getClickedObject(viewport, y, genomicLocation) {
+        const showSoftClips = this.parent.showSoftClips;
+        let features = viewport.getCachedFeatures();
+        if (!features || features.length === 0) return;
+        let packedAlignmentRows = features.packedAlignmentRows;
+        let downsampledIntervals = features.downsampledIntervals;
+        const alignmentRowHeight = this.displayMode === "SQUISHED" ? this.squishedRowHeight : this.alignmentRowHeight;
+        let packedAlignmentsIndex = Math.floor((y - this.top - this.alignmentsYOffset) / alignmentRowHeight);
+
+        if (packedAlignmentsIndex < 0) {
+          for (let i = 0; i < downsampledIntervals.length; i++) {
+            if (downsampledIntervals[i].start <= genomicLocation && downsampledIntervals[i].end >= genomicLocation) {
+              return downsampledIntervals[i];
+            }
+          }
+        } else if (packedAlignmentsIndex < packedAlignmentRows.length) {
+          const alignmentRow = packedAlignmentRows[packedAlignmentsIndex];
+          const clicked = alignmentRow.alignments.filter(alignment => alignment.containsLocation(genomicLocation, showSoftClips));
+          if (clicked.length > 0) return clicked[0];
+        }
+
+        return undefined;
+      }
+
+      /**
+       * Return the color for connectors in paired alignment view.   If explicitly set return that, otherwise return
+       * the alignment color, unless the color option can result in split colors (separte color for each mate).
+       *
+       * @param alignment
+       * @returns {string}
+       */
+      getConnectorColor(alignment) {
+        if (this.pairConnectorColor) {
+          return this.pairConnectorColor;
+        }
+
+        switch (this.colorBy) {
+          case "strand":
+          case "firstOfPairStrand":
+          case "pairOrientation":
+          case "tag":
+            return this.parent.color || DEFAULT_CONNECTOR_COLOR;
+
+          default:
+            return this.getAlignmentColor(alignment);
+        }
+      }
+
+      getAlignmentColor(alignment) {
+        let color = this.parent.color || DEFAULT_ALIGNMENT_COLOR; // The default color if nothing else applies
+
+        const option = this.colorBy;
+
+        switch (option) {
+          case "strand":
+            color = alignment.strand ? this.posStrandColor : this.negStrandColor;
+            break;
+
+          case "firstOfPairStrand":
+            if (alignment instanceof PairedAlignment) {
+              color = alignment.firstOfPairStrand() ? this.posStrandColor : this.negStrandColor;
+            } else if (alignment.isPaired()) {
+              if (alignment.isFirstOfPair()) {
+                color = alignment.strand ? this.posStrandColor : this.negStrandColor;
+              } else if (alignment.isSecondOfPair()) {
+                color = alignment.strand ? this.negStrandColor : this.posStrandColor;
+              } else {
+                console.error("ERROR. Paired alignments are either first or second.");
+              }
+            }
+
+            break;
+
+          case "pairOrientation":
+            if (alignment.mate && alignment.isMateMapped() && alignment.mate.chr !== alignment.chr) {
+              color = getChrColor(alignment.mate.chr);
+            } else if (this.pairOrientation && alignment.pairOrientation) {
+              var oTypes = orientationTypes[this.pairOrientation];
+
+              if (oTypes) {
+                var pairColor = this.pairColors[oTypes[alignment.pairOrientation]];
+                if (pairColor) color = pairColor;
+              }
+            }
+
+            break;
+
+          case "fragmentLength":
+            if (alignment.mate && alignment.isMateMapped() && alignment.mate.chr !== alignment.chr) {
+              color = getChrColor(alignment.mate.chr);
+            } else if (this.parent.minFragmentLength && Math.abs(alignment.fragmentLength) < this.parent.minFragmentLength) {
+              color = this.smallFragmentLengthColor;
+            } else if (this.parent.maxFragmentLength && Math.abs(alignment.fragmentLength) > this.parent.maxFragmentLength) {
+              color = this.largeFragmentLengthColor;
+            }
+
+            break;
+
+          case "tag":
+            const tagValue = alignment.tags()[this.colorByTag];
+
+            if (tagValue !== undefined) {
+              if (this.bamColorTag === this.colorByTag) {
+                // UCSC style color option
+                color = "rgb(" + tagValue + ")";
+              } else {
+                if (!this.tagColors) {
+                  this.tagColors = new PaletteColorTable("Set1");
+                }
+
+                color = this.tagColors.getColor(tagValue);
+              }
+            }
+
+            break;
+
+          default:
+            color = this.parent.color || DEFAULT_ALIGNMENT_COLOR;
+        }
+
+        return color;
+      }
+
+    }
+
+    function sortAlignmentRows(options, alignmentContainer) {
+      const direction = options.direction;
+
+      for (let row of alignmentContainer.packedAlignmentRows) {
+        row.updateScore(options, alignmentContainer);
+      }
+
+      alignmentContainer.packedAlignmentRows.sort(function (rowA, rowB) {
+        const i = rowA.score > rowB.score ? 1 : rowA.score < rowB.score ? -1 : 0;
+        return true === direction ? i : -i;
+      }); // For debugging
+      // for(let r of alignmentContainer.packedAlignmentRows) {
+      //     console.log(r.score);
+      // }
+    }
+
+    function shadedBaseColor(qual, baseColor) {
+      const minQ = 5; //prefs.getAsInt(PreferenceManager.SAM_BASE_QUALITY_MIN),
+
+      const maxQ = 20; //prefs.getAsInt(PreferenceManager.SAM_BASE_QUALITY_MAX);
+
+      let alpha;
+
+      if (qual < minQ) {
+        alpha = 0.1;
+      } else {
+        alpha = Math.max(0.1, Math.min(1.0, 0.1 + 0.9 * (qual - minQ) / (maxQ - minQ)));
+      } // Round alpha to nearest 0.1
+
+
+      alpha = Math.round(alpha * 10) / 10.0;
+
+      if (alpha < 1) {
+        baseColor = IGVColor.addAlpha(baseColor, alpha);
+      }
+
+      return baseColor;
+    }
+
+    const orientationTypes = {
+      "fr": {
+        "F1R2": "LR",
+        "F2R1": "LR",
+        "F1F2": "LL",
+        "F2F1": "LL",
+        "R1R2": "RR",
+        "R2R1": "RR",
+        "R1F2": "RL",
+        "R2F1": "RL"
+      },
+      "rf": {
+        "R1F2": "LR",
+        "R2F1": "LR",
+        "R1R2": "LL",
+        "R2R1": "LL",
+        "F1F2": "RR",
+        "F2F1": "RR",
+        "F1R2": "RL",
+        "F2R1": "RL"
+      },
+      "ff": {
+        "F2F1": "LR",
+        "R1R2": "LR",
+        "F2R1": "LL",
+        "R1F2": "LL",
+        "R2F1": "RR",
+        "F1R2": "RR",
+        "R2R1": "RL",
+        "F1F2": "RL"
+      }
+    };
+
+    function getChrColor(chr) {
+      if (chrColorMap[chr]) {
+        return chrColorMap[chr];
+      } else if (chrColorMap["chr" + chr]) {
+        const color = chrColorMap["chr" + chr];
+        chrColorMap[chr] = color;
+        return color;
+      } else {
+        const color = IGVColor.randomRGB();
+        chrColorMap[chr] = color;
+        return color;
+      }
+    }
+
+    const chrColorMap = {
+      "chrX": "rgb(204, 153, 0)",
+      "chrY": "rgb(153, 204, 0",
+      "chrUn": "rgb(50, 50, 50)",
+      "chr1": "rgb(80, 80, 255)",
+      "chrI": "rgb(139, 155, 187)",
+      "chr2": "rgb(206, 61, 50)",
+      "chrII": "rgb(206, 61, 50)",
+      "chr2a": "rgb(216, 71, 60)",
+      "chr2b": "rgb(226, 81, 70)",
+      "chr3": "rgb(116, 155, 88)",
+      "chrIII": "rgb(116, 155, 88)",
+      "chr4": "rgb(240, 230, 133)",
+      "chrIV": "rgb(240, 230, 133)",
+      "chr5": "rgb(70, 105, 131)",
+      "chr6": "rgb(186, 99, 56)",
+      "chr7": "rgb(93, 177, 221)",
+      "chr8": "rgb(128, 34, 104)",
+      "chr9": "rgb(107, 215, 107)",
+      "chr10": "rgb(213, 149, 167)",
+      "chr11": "rgb(146, 72, 34)",
+      "chr12": "rgb(131, 123, 141)",
+      "chr13": "rgb(199, 81, 39)",
+      "chr14": "rgb(213, 143, 92)",
+      "chr15": "rgb(122, 101, 165)",
+      "chr16": "rgb(228, 175, 105)",
+      "chr17": "rgb(59, 27, 83)",
+      "chr18": "rgb(205, 222, 183)",
+      "chr19": "rgb(97, 42, 121)",
+      "chr20": "rgb(174, 31, 99)",
+      "chr21": "rgb(231, 199, 111)",
+      "chr22": "rgb(90, 101, 94)",
+      "chr23": "rgb(204, 153, 0)",
+      "chr24": "rgb(153, 204, 0)",
+      "chr25": "rgb(51, 204, 0)",
+      "chr26": "rgb(0, 204, 51)",
+      "chr27": "rgb(0, 204, 153)",
+      "chr28": "rgb(0, 153, 204)",
+      "chr29": "rgb(10, 71, 255)",
+      "chr30": "rgb(71, 117, 255)",
+      "chr31": "rgb(255, 194, 10)",
+      "chr32": "rgb(255, 209, 71)",
+      "chr33": "rgb(153, 0, 51)",
+      "chr34": "rgb(153, 26, 0)",
+      "chr35": "rgb(153, 102, 0)",
+      "chr36": "rgb(128, 153, 0)",
+      "chr37": "rgb(51, 153, 0)",
+      "chr38": "rgb(0, 153, 26)",
+      "chr39": "rgb(0, 153, 102)",
+      "chr40": "rgb(0, 128, 153)",
+      "chr41": "rgb(0, 51, 153)",
+      "chr42": "rgb(26, 0, 153)",
+      "chr43": "rgb(102, 0, 153)",
+      "chr44": "rgb(153, 0, 128)",
+      "chr45": "rgb(214, 0, 71)",
+      "chr46": "rgb(255, 20, 99)",
+      "chr47": "rgb(0, 214, 143)",
+      "chr48": "rgb(20, 255, 177)"
+    };
+
+    /*
+     * The MIT License (MIT)
+     *
+     * Copyright (c) 2016-2018 The Regents of the University of California
+     * Author: Jim Robinson
+     *
+     * Permission is hereby granted, free of charge, to any person obtaining a copy
+     * of this software and associated documentation files (the "Software"), to deal
+     * in the Software without restriction, including without limitation the rights
+     * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+     * copies of the Software, and to permit persons to whom the Software is
+     * furnished to do so, subject to the following conditions:
+     *
+     * The above copyright notice and this permission notice shall be included in
+     * all copies or substantial portions of the Software.
+     *
+     *
+     * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+     * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+     * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+     * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+     * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+     * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+     * THE SOFTWARE.
+     */
+
+    class InteractionTrack extends TrackBase {
+      constructor(config, browser) {
+        super(config, browser);
+      }
+
+      init(config) {
+        super.init(config);
+        this.theta = config.theta || Math.PI / 4;
+        this.sinTheta = Math.sin(this.theta);
+        this.cosTheta = Math.cos(this.theta);
+        this.height = config.height || 250;
+        this.arcType = config.arcType || "nested"; // nested | proportional
+
+        this.arcOrientation = config.arcOrientation === undefined ? true : config.arcOrientation; // true for up, false for down
+
+        this.showBlocks = config.showBlocks === undefined ? true : config.showBlocks;
+        this.blockHeight = config.blockHeight || 3;
+        this.thickness = config.thickness || 1;
+        this.color = config.color || "rgb(180,25,137)";
+        this.alpha = config.alpha || 0.15;
+
+        if (config.valueColumn) {
+          this.valueColumn = config.valueColumn;
+          this.hasValue = true;
+        } else if (config.useScore) {
+          this.hasValue = true;
+          this.valueColumn = "score";
+        }
+
+        this.logScale = config.logScale !== false; // i.e. defaul to true (undefined => true)
+
+        if (config.max) {
+          this.dataRange = {
+            min: config.min || 0,
+            max: config.max
+          };
+          this.autoscale = false;
+        } else {
+          this.autoscale = true;
+        } // Create the FeatureSource and override the default whole genome method
+
+
+        this.featureSource = FeatureSource(config, this.browser.genome);
+        this.featureSource.getWGFeatures = getWGFeatures;
+      }
+
+      async postInit() {
+        if (typeof this.featureSource.getHeader === "function") {
+          this.header = await this.featureSource.getHeader();
+        } // Set properties from track line
+
+
+        if (this.header) {
+          this.setTrackProperties(this.header);
+        }
+
+        if (this.visibilityWindow === undefined && typeof this.featureSource.defaultVisibilityWindow === 'function') {
+          this.visibilityWindow = await this.featureSource.defaultVisibilityWindow();
+          this.featureSource.visibilityWindow = this.visibilityWindow; // <- this looks odd
+        }
+
+        return this;
+      }
+
+      supportsWholeGenome() {
+        return true;
+      }
+
+      async getFeatures(chr, start, end) {
+        const visibilityWindow = this.visibilityWindow;
+        const features = await this.featureSource.getFeatures({
+          chr,
+          start,
+          end,
+          visibilityWindow
+        }); // Check for score or value
+
+        if (this.hasValue === undefined && features && features.length > 0) {
+          this.hasValue = features[0].score !== undefined;
+        }
+
+        return features;
+      }
+
+      draw(options) {
+        if (this.arcType === "proportional") {
+          this.drawProportional(options);
+        } else {
+          this.drawNested(options);
+        }
+      }
+
+      drawNested(options) {
+        const ctx = options.context;
+        const pixelWidth = options.pixelWidth;
+        const pixelHeight = options.pixelHeight;
+        const viewportWidth = options.viewportWidth;
+        const bpPerPixel = options.bpPerPixel;
+        const bpStart = options.bpStart;
+        const xScale = bpPerPixel;
+        IGVGraphics.fillRect(ctx, 0, options.pixelTop, pixelWidth, pixelHeight, {
+          'fillStyle': "rgb(255, 255, 255)"
+        });
+        const featureList = options.features;
+
+        if (featureList) {
+          // Autoscale theta
+          autoscaleNested.call(this);
+          const y = this.arcOrientation ? options.pixelHeight : 0;
+          const direction = this.arcOrientation;
+          ctx.font = "8px";
+          ctx.textAlign = "center";
+
+          for (let feature of featureList) {
+            let color = feature.color || this.color;
+
+            if (color && this.config.useScore) {
+              color = getAlphaColor(color, scoreShade(feature.score));
+            }
+
+            ctx.lineWidth = feature.thickness || this.thickness || 1;
+
+            if (feature.chr1 === feature.chr2 || feature.chr === 'all') {
+              const {
+                m1,
+                m2
+              } = getMidpoints(feature, this.browser.genome);
+              let pixelStart = Math.round((m1 - bpStart) / xScale);
+              let pixelEnd = Math.round((m2 - bpStart) / xScale);
+              if (pixelEnd < 0 || pixelStart > pixelWidth) continue;
+              let w = pixelEnd - pixelStart;
+
+              if (w < 3) {
+                w = 3;
+                pixelStart--;
+              }
+
+              const a = w / 2;
+              const r = a / this.sinTheta;
+              const b = this.cosTheta * r;
+              const xc = pixelStart + a;
+              let yc, startAngle, endAngle;
+
+              if (direction) {
+                // UP
+                yc = this.height + b;
+                startAngle = Math.PI + Math.PI / 2 - this.theta;
+                endAngle = Math.PI + Math.PI / 2 + this.theta;
+              } else {
+                // DOWN
+                yc = -b;
+                startAngle = Math.PI / 2 - this.theta;
+                endAngle = Math.PI / 2 + this.theta;
+              }
+
+              if (this.showBlocks && feature.chr !== 'all') {
+                const s1 = (feature.start1 - bpStart) / xScale;
+                const e1 = (feature.end1 - bpStart) / xScale;
+                const s2 = (feature.start2 - bpStart) / xScale;
+                const e2 = (feature.end2 - bpStart) / xScale;
+                const hb = this.arcOrientation ? -this.blockHeight : this.blockHeight;
+                ctx.fillRect(s1, y, e1 - s1, hb);
+                ctx.fillRect(s2, y, e2 - s2, hb);
+              } // Alpha shade (de-emphasize) arcs that extend beyond viewport, unless alpha shading is used for score.
+
+
+              if (color && !this.config.useScore && w > viewportWidth) {
+                color = getAlphaColor(color, this.alpha);
+              }
+
+              ctx.strokeStyle = color;
+              ctx.fillStyle = color;
+              ctx.beginPath();
+              ctx.arc(xc, yc, r, startAngle, endAngle, false);
+              ctx.stroke();
+              feature.drawState = {
+                xc,
+                yc,
+                r
+              };
+            } else {
+              let pixelStart = Math.round((feature.start - bpStart) / xScale);
+              let pixelEnd = Math.round((feature.end - bpStart) / xScale);
+              if (pixelEnd < 0 || pixelStart > pixelWidth) continue;
+              let w = pixelEnd - pixelStart;
+
+              if (w < 3) {
+                w = 3;
+                pixelStart--;
+              }
+
+              const otherChr = feature.chr === feature.chr1 ? feature.chr2 : feature.chr1;
+              ctx.strokeStyle = color;
+              ctx.fillStyle = color;
+
+              if (direction) {
+                // UP
+                ctx.fillRect(pixelStart, this.height / 2, w, this.height / 2);
+                ctx.fillText(otherChr, pixelStart + w / 2, this.height / 2 - 5);
+                feature.drawState = {
+                  x: pixelStart,
+                  y: this.height / 2,
+                  w: w,
+                  h: this.height / 2
+                };
+              } else {
+                ctx.fillRect(pixelStart, 0, w, this.height / 2);
+                ctx.fillText(otherChr, pixelStart + w / 2, this.height / 2 + 13);
+                feature.drawState = {
+                  x: pixelStart,
+                  y: 0,
+                  w: w,
+                  h: this.height / 2
+                };
+              }
+            }
+          }
+        }
+
+        function autoscaleNested() {
+          let max = 0;
+
+          for (let feature of featureList) {
+            let pixelStart = (feature.start - bpStart) / xScale;
+            let pixelEnd = (feature.end - bpStart) / xScale;
+
+            if (pixelEnd >= 0 && pixelStart <= pixelWidth) {
+              max = Math.max(max, pixelEnd - pixelStart);
+            }
+          }
+
+          let a = Math.min(viewportWidth, max) / 2;
+
+          if (max > 0) {
+            let coa = (pixelHeight - 10) / a;
+            this.theta = estimateTheta(coa);
+            this.sinTheta = Math.sin(this.theta);
+            this.cosTheta = Math.cos(this.theta);
+          }
+        }
+      }
+
+      drawProportional(options) {
+        const ctx = options.context;
+        const pixelWidth = options.pixelWidth;
+        const pixelHeight = options.pixelHeight;
+        const bpPerPixel = options.bpPerPixel;
+        const bpStart = options.bpStart;
+        const xScale = bpPerPixel;
+        IGVGraphics.fillRect(ctx, 0, options.pixelTop, pixelWidth, pixelHeight, {
+          'fillStyle': "rgb(255, 255, 255)"
+        });
+        const featureList = options.features;
+
+        if (featureList && featureList.length > 0) {
+          const yScale = this.logScale ? options.pixelHeight / Math.log10(this.dataRange.max + 1) : options.pixelHeight / (this.dataRange.max - this.dataRange.min);
+          const y = this.arcOrientation ? options.pixelHeight : 0;
+
+          for (let feature of featureList) {
+            ctx.save();
+            const value = this.valueColumn ? feature[this.valueColumn] : feature.score;
+            if (value === undefined || Number.isNaN(value)) continue;
+            const radiusY = this.logScale ? Math.log10(value + 1) * yScale : value * yScale;
+
+            if (feature.chr1 === feature.chr2 || feature.chr === 'all') {
+              const {
+                m1,
+                m2
+              } = getMidpoints(feature, this.browser.genome);
+              let pixelStart = (m1 - bpStart) / xScale;
+              let pixelEnd = (m2 - bpStart) / xScale;
+              let w = pixelEnd - pixelStart;
+
+              if (w < 3) {
+                w = 3;
+                pixelStart--;
+              }
+
+              if (pixelEnd < 0 || pixelStart > pixelWidth || value < this.dataRange.min) continue;
+              const radiusX = w / 2;
+              const xc = pixelStart + w / 2;
+              const counterClockwise = this.arcOrientation ? true : false;
+              const color = feature.color || this.color;
+              ctx.strokeStyle = color;
+              ctx.lineWidth = feature.thickness || this.thickness || 1;
+              ctx.beginPath();
+              ctx.ellipse(xc, y, radiusX, radiusY, 0, 0, Math.PI, counterClockwise);
+              ctx.stroke();
+
+              if (this.showBlocks && feature.chr !== 'all') {
+                ctx.fillStyle = color;
+                const s1 = (feature.start1 - bpStart) / xScale;
+                const e1 = (feature.end1 - bpStart) / xScale;
+                const s2 = (feature.start2 - bpStart) / xScale;
+                const e2 = (feature.end2 - bpStart) / xScale;
+                const hb = this.arcOrientation ? -this.blockHeight : this.blockHeight;
+                ctx.fillRect(s1, y, e1 - s1, hb);
+                ctx.fillRect(s2, y, e2 - s2, hb);
+              }
+
+              if (this.alpha) {
+                const alphaColor = getAlphaColor(color, this.alpha);
+                ctx.fillStyle = alphaColor;
+                ctx.fill();
+              }
+
+              ctx.restore();
+              feature.drawState = {
+                xc,
+                yc: y,
+                radiusX,
+                radiusY
+              };
+            } else {
+              let pixelStart = Math.round((feature.start - bpStart) / xScale);
+              let pixelEnd = Math.round((feature.end - bpStart) / xScale);
+              if (pixelEnd < 0 || pixelStart > pixelWidth || value < this.dataRange.min) continue;
+              const h = Math.min(radiusY, this.height - 13); // Leave room for text
+
+              let w = pixelEnd - pixelStart;
+
+              if (w < 3) {
+                w = 3;
+                pixelStart--;
+              }
+
+              const otherChr = feature.chr === feature.chr1 ? feature.chr2 : feature.chr1;
+              ctx.font = "8px";
+              ctx.textAlign = "center";
+
+              if (this.arcOrientation) {
+                // UP
+                const y = this.height - h;
+                ctx.fillRect(pixelStart, y, w, h);
+                ctx.fillText(otherChr, pixelStart + w / 2, y - 5);
+                feature.drawState = {
+                  x: pixelStart,
+                  y,
+                  w,
+                  h
+                };
+              } else {
+                ctx.fillRect(pixelStart, 0, w, h);
+                ctx.fillText(otherChr, pixelStart + w / 2, h + 13);
+                feature.drawState = {
+                  x: pixelStart,
+                  y: 0,
+                  w,
+                  h
+                };
+              }
+            }
+          }
+        }
+      }
+
+      menuItemList() {
+        let items = [{
+          name: "Set track color",
+          click: () => {
+            this.trackView.presentColorPicker();
+          }
+        }, '<HR/>'];
+
+        if (this.hasValue) {
+          const lut = {
+            "nested": "Nested Arcs",
+            "proportional": "Proportional Arcs"
+          };
+
+          for (let arcType of ["nested", "proportional"]) {
+            items.push({
+              object: createCheckbox$1(lut[arcType], arcType === this.arcType),
+              click: () => {
+                this.arcType = arcType;
+                this.trackView.repaintViews();
+              }
+            });
+          }
+        }
+
+        items.push({
+          object: createCheckbox$1("Show Blocks", this.showBlocks),
+          click: () => {
+            this.showBlocks = !this.showBlocks;
+            this.trackView.repaintViews();
+          }
+        });
+        items.push({
+          name: "Toggle arc direction",
+          click: () => {
+            this.arcOrientation = !this.arcOrientation;
+            this.trackView.repaintViews();
+          }
+        });
+
+        if (this.arcType === "proportional") {
+          items.push("<HR>");
+          items = items.concat(MenuUtils.numericDataMenuItems(this.trackView));
+        }
+
+        return items;
+      }
+
+      doAutoscale(features) {
+        // if ("proportional" === this.arcType) {
+        let max = 0;
+
+        if (features) {
+          for (let f of features) {
+            const v = this.valueColumn ? f[this.valueColumn] : f.score;
+
+            if (!Number.isNaN(v)) {
+              max = Math.max(max, v);
+            }
+          }
+        }
+
+        return {
+          min: 0,
+          max: max
+        }; // }
+      }
+
+      popupData(clickState, features) {
+        features = this.clickedFeatures(clickState);
+        const data = [];
+
+        for (let feature of features) {
+          const f = feature._ || feature; // For "whole genome" features, which keeps a pointer to the original
+
+          data.push({
+            name: "Region 1",
+            value: positionString(f.chr1, f.start1, f.end1, f.strand1)
+          });
+          data.push({
+            name: "Region 2",
+            value: positionString(f.chr2, f.start2, f.end2, f.strand2)
+          });
+
+          if (f.name) {
+            data.push({
+              name: "Name",
+              value: f.name
+            });
+          }
+
+          if (f.value !== undefined) {
+            data.push({
+              name: "Value",
+              value: f.value
+            });
+          }
+
+          if (f.score !== undefined) {
+            data.push({
+              name: "Score",
+              value: f.score
+            });
+          }
+
+          if (f.extras && this.header && this.header.columnNames) {
+            const columnNames = this.header.columnNames;
+
+            for (let i = 10; i < columnNames.length; i++) {
+              if (columnNames[i] === 'info') {
+                extractInfoColumn(data, f.extras[i - 10]);
+              } else {
+                data.push({
+                  name: columnNames[i],
+                  value: f.extras[i - 10]
+                });
+              }
+            }
+          } // For now just return the top hit
+
+
+          break; //if (data.length > 0) {
+          //     data.push("<HR>");
+          // }
+        }
+
+        return data;
+      }
+
+      clickedFeatures(clickState, features) {
+        // We use the cached features rather than method to avoid async load.  If the
+        // feature is not already loaded this won't work,  but the user wouldn't be mousing over it either.
+        const featureList = features || clickState.viewport.getCachedFeatures();
+        const candidates = [];
+
+        if (featureList) {
+          const proportional = this.arcType === "proportional";
+
+          for (let feature of featureList) {
+            if (!feature.drawState) continue;
+
+            if (feature.chr1 === feature.chr2 || feature.chr === 'all') {
+              if (proportional) {
+                //(x-xc)^2/radiusX^2 + (y-yc)^2/radiusY^2 <= 1
+                const {
+                  xc,
+                  yc,
+                  radiusX,
+                  radiusY
+                } = feature.drawState;
+                const dx = clickState.canvasX - xc;
+                const dy = clickState.canvasY - yc;
+                const score = dx / radiusX * (dx / radiusX) + dy / radiusY * (dy / radiusY);
+
+                if (score <= 1) {
+                  candidates.push({
+                    score: 1 / score,
+                    feature
+                  });
+                }
+              } else {
+                const {
+                  xc,
+                  yc,
+                  r
+                } = feature.drawState;
+                const dx = clickState.canvasX - xc;
+                const dy = clickState.canvasY - yc;
+                const score = Math.abs(Math.sqrt(dx * dx + dy * dy) - r);
+
+                if (score < 5) {
+                  candidates.push({
+                    score,
+                    feature
+                  });
+                }
+              }
+            } else {
+              const {
+                x,
+                y,
+                w,
+                h
+              } = feature.drawState;
+              const tolerance = 5;
+
+              if (clickState.canvasX >= x - tolerance && clickState.canvasX <= x + w + tolerance && clickState.canvasY >= y && clickState.canvasY <= y + h) {
+                const score = -Math.abs(clickState.canvasX - (x + w / 2));
+                candidates.push({
+                  score,
+                  feature
+                });
+                break;
+              }
+            }
+          }
+        }
+
+        if (candidates.length > 1) {
+          candidates.sort((a, b) => a.score - b.score);
+        }
+
+        return candidates.map(c => c.feature);
+      }
+
+    }
+
+    function getMidpoints(feature, genome) {
+      let m1 = (feature.start1 + feature.end1) / 2;
+      let m2 = (feature.start2 + feature.end2) / 2;
+
+      if (feature.chr === 'all') {
+        m1 = genome.getGenomeCoordinate(feature.chr1, m1);
+        m2 = genome.getGenomeCoordinate(feature.chr2, m2);
+      }
+
+      if (m1 > m2) {
+        const tmp = m1;
+        m1 = m2;
+        m2 = tmp;
+      }
+
+      return {
+        m1,
+        m2
+      };
+    }
+
+    function positionString(chr, start, end, strand) {
+      return strand && strand !== '.' ? `${chr}:${numberFormatter$1(start + 1)}-${numberFormatter$1(end)} (${strand})` : `${chr}:${numberFormatter$1(start + 1)}-${numberFormatter$1(end)}`;
+    }
+    /**
+     * Estimate theta given the ratio of track height to 1/2 the feature width (coa).  This relationship is approximately linear.
+     */
+
+
+    function estimateTheta(x) {
+      let coa = [0.01570925532366355, 0.15838444032453644, 0.3249196962329063, 0.5095254494944288, 0.7265425280053609, 0.9999999999999999];
+      let theta = [0.031415926535897934, 0.3141592653589793, 0.6283185307179586, 0.9424777960769379, 1.2566370614359172, 1.5707963267948966];
+      let idx;
+
+      for (idx = 0; idx < coa.length; idx++) {
+        if (coa[idx] > x) {
+          break;
+        }
+      }
+
+      let left = idx === 0 ? 0 : coa[idx - 1];
+      let right = idx < coa.length ? coa[idx] : 1;
+      let r = (x - left) / (right - left);
+      let thetaLeft = idx === 0 ? 0 : theta[idx - 1];
+      let thetaRight = idx < theta.length ? theta[idx] : Math.PI / 2;
+      return thetaLeft + r * (thetaRight - thetaLeft);
+    }
+
+    const colorAlphaCache = new Map();
+
+    function getAlphaColor(color, alpha) {
+      const key = `${color}_${alpha}`;
+      let c = colorAlphaCache.get(key);
+
+      if (!c) {
+        c = IGVColor.addAlpha(color, alpha);
+        colorAlphaCache.set(key, c);
+      }
+
+      return c;
+    }
+    /**
+     * Called in the context of FeatureSource
+     * @param allFeatures
+     * @returns {[]}
+     */
+
+
+    function getWGFeatures(allFeatures) {
+      const genome = this.genome;
+      const wgFeatures = [];
+
+      for (let c of genome.wgChromosomeNames) {
+        const chrFeatures = allFeatures[c];
+
+        if (chrFeatures) {
+          for (let f of chrFeatures) {
+            if (!f.dup) {
+              const wg = Object.assign({}, f);
+              wg.chr = "all";
+              wg.start = genome.getGenomeCoordinate(f.chr1, f.start1);
+              wg.end = genome.getGenomeCoordinate(f.chr2, f.end2);
+              wgFeatures.push(wg);
+            }
+          }
+        }
+      }
+
+      return wgFeatures;
+    }
+    /**
+     * Extract a gff style info column for popup text.  This convention used by 10X for bedpe files
+     *     ALLELIC_FRAC=0.0375670840787;BLACK1=.;BLACK2=.;...
+     * @param data
+     * @param str
+     */
+
+
+    function extractInfoColumn(data, str) {
+      const kvs = str.split(';');
+
+      for (let t of kvs) {
+        const kv = t.split('=');
+
+        if (kv.length === 2) {
+          data.push({
+            name: kv[0],
+            value: kv[1]
+          });
+        }
+      }
+    }
+
+    /*
+     * The MIT License (MIT)
+     *
+     * Copyright (c) 2016 University of California San Diego
+     * Author: Jim Robinson
+     *
+     * Permission is hereby granted, free of charge, to any person obtaining a copy
+     * of this software and associated documentation files (the "Software"), to deal
+     * in the Software without restriction, including without limitation the rights
+     * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+     * copies of the Software, and to permit persons to whom the Software is
+     * furnished to do so, subject to the following conditions:
+     *
+     * The above copyright notice and this permission notice shall be included in
+     * all copies or substantial portions of the Software.
+     *
+     *
+     * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+     * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+     * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+     * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+     * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+     * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+     * THE SOFTWARE.
+     */
+    const isString = isString$6;
+    const DEFAULT_VISIBILITY_WINDOW = 1000000;
+    const TOP_MARGIN = 10;
+
+    class VariantTrack extends TrackBase {
+      constructor(config, browser) {
+        super(config, browser);
+      }
+
+      init(config) {
+        super.init(config);
+        this.visibilityWindow = config.visibilityWindow;
+        this.displayMode = config.displayMode || "EXPANDED"; // COLLAPSED | EXPANDED | SQUISHED
+
+        this.labelDisplayMode = config.labelDisplayMode;
+        this.expandedVariantHeight = config.expandedVariantHeight || config.variantHeight || 10;
+        this.squishedVariantHeight = config.squishedVariantHeight || 2;
+        this.squishedCallHeight = config.squishedCallHeight || 1;
+        this.expandedCallHeight = config.expandedCallHeight || 10;
+        this.expandedVGap = config.expandedVGap !== undefined ? config.expandedVGap : 2;
+        this.squishedVGap = config.squishedVGap !== undefined ? config.squishedVGap : 1;
+        this.expandedGroupGap = config.expandedGroupGap || 10;
+        this.squishedGroupGap = config.squishedGroupGap || 5;
+        this.featureHeight = config.featureHeight || 14;
+        this.visibilityWindow = config.visibilityWindow;
+        this.featureSource = FeatureSource(config, this.browser.genome);
+        this.noGenotypeColor = config.noGenotypeColor || "rgb(200,180,180)";
+        this.noCallColor = config.noCallColor || "rgb(225, 225, 225)";
+        this.nonRefColor = config.nonRefColor || "rgb(200, 200, 215)";
+        this.mixedColor = config.mixedColor || "rgb(200, 220, 200)";
+        this.homrefColor = config.homrefColor || "rgb(200, 200, 200)";
+        this.homvarColor = config.homvarColor || "rgb(17,248,254)";
+        this.hetvarColor = config.hetvarColor || "rgb(34,12,253)";
+        this.sortDirection = "ASC";
+        this.type = config.type || "variant";
+
+        if (config.colorBy) {
+          this.colorBy = config.colorBy; // Can be undefined => default
+
+          this._initColorBy = config.colorBy;
+
+          if (config.colorTable) {
+            this.colorTables = new Map();
+            this.colorTables.set(config.colorBy, new ColorTable(config.colorTable));
+          }
+        }
+
+        this._color = config.color;
+        this.showGenotypes = config.showGenotypes === undefined ? true : config.showGenotypes; // The number of variant rows are computed dynamically, but start with "1" by default
+
+        this.variantRowCount(1);
+      }
+
+      async postInit() {
+        this.header = await this.getHeader(); // cricital, don't remove'
+
+        if (undefined === this.visibilityWindow && this.config.indexed !== false) {
+          const fn = this.config.url instanceof File ? this.config.url.name : this.config.url;
+
+          if (isString(fn) && fn.toLowerCase().includes("gnomad")) {
+            this.visibilityWindow = 1000; // these are known to be very dense
+          } else if (this.callSets) {
+            const length = this.callSets.length;
+            this.visibilityWindow = Math.max(1000, DEFAULT_VISIBILITY_WINDOW - length * (DEFAULT_VISIBILITY_WINDOW / 100));
+          } else {
+            this.visibilityWindow = DEFAULT_VISIBILITY_WINDOW;
+          }
+        }
+
+        return this;
+      }
+
+      supportsWholeGenome() {
+        return this.config.indexed === false && this.config.supportsWholeGenome !== false;
+      }
+
+      get color() {
+        return this._color;
+      }
+
+      set color(c) {
+        this._color = c;
+        this.colorBy = undefined;
+      }
+
+      async getHeader() {
+        if (!this.header) {
+          if (typeof this.featureSource.getHeader === "function") {
+            const header = await this.featureSource.getHeader();
+
+            if (header) {
+              this.callSets = header.callSets || [];
+            }
+
+            this.header = header;
+          }
+
+          this.sampleNames = this.callSets ? this.callSets.map(cs => cs.name) : [];
+        }
+
+        return this.header;
+      }
+
+      getCallsetsLength() {
+        return this.callSets.length;
+      }
+
+      async getFeatures(chr, start, end, bpPerPixel) {
+        if (this.header === undefined) {
+          this.header = await this.getHeader();
+        }
+
+        return this.featureSource.getFeatures({
+          chr,
+          start,
+          end,
+          bpPerPixel,
+          visibilityWindow: this.visibilityWindow
+        });
+      }
+
+      hasSamples() {
+        return this.getCallsetsLength() > 0;
+      }
+
+      getSamples() {
+        return {
+          yOffset: this.sampleYOffset,
+          names: this.sampleNames,
+          height: this.sampleHeight
+        };
+      }
+      /**
+       * The required height in pixels required for the track content.   This is not the visible track height, which
+       * can be smaller (with a scrollbar) or larger.
+       *
+       * @param features
+       * @returns {*}
+       */
+
+
+      computePixelHeight(features) {
+        if (!features || features.length == 0) return TOP_MARGIN;
+        const nVariantRows = this.displayMode === "COLLAPSED" ? 1 : this.nVariantRows;
+        const vGap = this.displayMode === "SQUISHED" ? this.squishedVGap : this.expandedVGap;
+        const variantHeight = this.displayMode === "SQUISHED" ? this.squishedVariantHeight : this.expandedVariantHeight;
+        const callHeight = this.displayMode === "SQUISHED" ? this.squishedCallHeight : this.expandedCallHeight;
+        const nCalls = this.showGenotypes === false ? 0 : this.getCallsetsLength() * nVariantRows;
+        const h = TOP_MARGIN + nVariantRows * (variantHeight + vGap);
+        return h + vGap + (nCalls + 1) * (callHeight + vGap);
+      }
+
+      variantRowCount(count) {
+        this.nVariantRows = count;
+      }
+
+      draw({
+        context,
+        pixelWidth,
+        pixelHeight,
+        bpPerPixel,
+        bpStart,
+        pixelTop,
+        features
+      }) {
+        IGVGraphics.fillRect(context, 0, pixelTop, pixelWidth, pixelHeight, {
+          'fillStyle': "rgb(255, 255, 255)"
+        });
+        const vGap = "SQUISHED" === this.displayMode ? this.squishedVGap : this.expandedVGap;
+        const rc = "COLLAPSED" === this.displayMode ? 1 : this.nVariantRows;
+        const variantHeight = "SQUISHED" === this.displayMode ? this.squishedVariantHeight : this.expandedVariantHeight;
+        this.variantBandHeight = TOP_MARGIN + rc * (variantHeight + vGap);
+        const callSets = this.callSets;
+        const nCalls = this.getCallsetsLength();
+
+        if (callSets && nCalls > 0 && this.showGenotypes !== false) {
+          IGVGraphics.strokeLine(context, 0, this.variantBandHeight, pixelWidth, this.variantBandHeight, {
+            strokeStyle: 'rgb(224,224,224) '
+          });
+        }
+
+        if (features) {
+          const callHeight = "SQUISHED" === this.displayMode ? this.squishedCallHeight : this.expandedCallHeight;
+          const vGap = "SQUISHED" === this.displayMode ? this.squishedVGap : this.expandedVGap;
+          const bpEnd = bpStart + pixelWidth * bpPerPixel + 1; // Loop through variants.  A variant == a row in a VCF file
+
+          for (let variant of features) {
+            if (variant.end < bpStart) continue;
+            if (variant.start > bpEnd) break;
+            const variantHeight = "SQUISHED" === this.displayMode ? this.squishedVariantHeight : this.expandedVariantHeight;
+            const y = TOP_MARGIN + ("COLLAPSED" === this.displayMode ? 0 : variant.row * (variantHeight + vGap));
+            const h = variantHeight; // Compute pixel width.   Minimum width is 3 pixels,  if > 5 pixels create gap between variants
+
+            let x = Math.round((variant.start - bpStart) / bpPerPixel);
+            let x1 = Math.round((variant.end - bpStart) / bpPerPixel);
+            let w = Math.max(1, x1 - x);
+
+            if (w < 3) {
+              w = 3;
+              x -= 1;
+            } else if (w > 5) {
+              x += 1;
+              w -= 2;
+            }
+
+            context.fillStyle = this.getVariantColor(variant);
+            context.fillRect(x, y, w, h);
+            variant.pixelRect = {
+              x,
+              y,
+              w,
+              h
+            }; // Loop though the calls for this variant.  There will potentially be a call for each sample.
+
+            if (nCalls > 0 && this.showGenotypes !== false) {
+              const nVariantRows = "COLLAPSED" === this.displayMode ? 1 : this.nVariantRows;
+              this.sampleYOffset = this.variantBandHeight + vGap;
+              this.sampleHeight = nVariantRows * (callHeight + vGap); // For each sample, there is a call for each variant at this position
+
+              let sampleNumber = 0;
+
+              for (let callSet of callSets) {
+                const call = variant.calls[callSet.id];
+
+                if (call) {
+                  const row = "COLLAPSED" === this.displayMode ? 0 : variant.row;
+                  const py = this.sampleYOffset + sampleNumber * this.sampleHeight + row * (callHeight + vGap);
+                  let allVar = true; // until proven otherwise
+
+                  let allRef = true;
+                  let noCall = false;
+
+                  if (call.genotype) {
+                    for (let g of call.genotype) {
+                      if ('.' === g) {
+                        noCall = true;
+                        break;
+                      } else {
+                        if (g !== 0) allRef = false;
+                        if (g === 0) allVar = false;
+                      }
+                    }
+                  }
+
+                  if (!call.genotype) {
+                    context.fillStyle = this.noGenotypeColor;
+                  } else if (noCall) {
+                    context.fillStyle = this.noCallColor;
+                  } else if (allRef) {
+                    context.fillStyle = this.homrefColor;
+                  } else if (allVar) {
+                    context.fillStyle = this.homvarColor;
+                  } else {
+                    context.fillStyle = this.hetvarColor;
+                  }
+
+                  context.fillRect(x, py, w, callHeight);
+                  callSet.pixelRect = {
+                    x,
+                    y: py,
+                    w,
+                    h: callHeight
+                  };
+                }
+
+                sampleNumber++;
+              }
+            }
+          }
+        }
+      }
+
+      getVariantColor(variant) {
+        let variantColor;
+
+        if (this.colorBy) {
+          const value = variant.info[this.colorBy];
+          variantColor = this.getVariantColorTable(this.colorBy).getColor(value);
+
+          if (!variantColor) {
+            variantColor = "gray";
+          }
+        } else if (this._color) {
+          variantColor = typeof this._color === "function" ? this._color(variant) : this._color;
+        } else if ("NONVARIANT" === variant.type) {
+          variantColor = this.nonRefColor;
+        } else if ("MIXED" === variant.type) {
+          variantColor = this.mixedColor;
+        } else {
+          variantColor = this.defaultColor;
+        }
+
+        return variantColor;
+      }
+      /**
+       * Return "popup data" for feature @ genomic location.  Data is an array of key-value pairs
+       */
+
+
+      popupData(clickState, featureList) {
+        featureList = this.clickedFeatures(clickState, featureList);
+        const genomicLocation = clickState.genomicLocation;
+        const genomeID = this.browser.genome.id;
+        const sampleInformation = this.browser.sampleInformation;
+        const vGap = this.displayMode === 'EXPANDED' ? this.expandedVGap : this.squishedVGap;
+        const callHeight = vGap + ("SQUISHED" === this.displayMode ? this.squishedCallHeight : this.expandedCallHeight); // Find the variant row (i.e. row assigned during feature packing)
+
+        const yOffset = clickState.y;
+        let row;
+        let sampleRow;
+
+        if (yOffset <= this.variantBandHeight) {
+          // Variant
+          const variantHeight = "SQUISHED" === this.displayMode ? this.squishedVariantHeight : this.expandedVariantHeight;
+          row = Math.floor((yOffset - TOP_MARGIN) / (variantHeight + vGap));
+          sampleRow = -1;
+        } else {
+          const sampleY = yOffset - this.variantBandHeight;
+          sampleRow = Math.floor(sampleY / this.sampleHeight);
+          row = Math.floor((sampleY - sampleRow * this.sampleHeight) / callHeight);
+        }
+
+        const rowVariants = featureList.filter(f => f.row === row);
+        let popupData = [];
+
+        for (let variant of rowVariants) {
+          if (popupData.length > 0) {
+            popupData.push({
+              html: '<hr style="border-top-width:2px ;border-color: #c9c3ba" />'
+            });
+          }
+
+          if (yOffset <= this.variantBandHeight) {
+            const v = variant.popupData(genomicLocation, genomeID);
+            Array.prototype.push.apply(popupData, v);
+          } else {
+            // Callset
+            const callSets = this.callSets;
+
+            if (callSets && variant.calls) {
+              if (sampleRow >= 0 && sampleRow < callSets.length) {
+                const cs = callSets[sampleRow];
+                const call = variant.calls[cs.id];
+                Array.prototype.push.apply(popupData, extractGenotypePopupData(call, variant, genomeID, sampleInformation));
+              }
+            }
+          }
+        }
+
+        return popupData;
+        /**
+         * Genotype popup text.
+         * @param call
+         * @param variant
+         * @returns {Array}
+         */
+
+        function extractGenotypePopupData(call, variant, genomeId, sampleInformation) {
+          let popupData = [];
+
+          if (call.callSetName !== undefined) {
+            popupData.push({
+              name: 'Name',
+              value: call.callSetName
+            });
+          }
+
+          if (call.genotype) {
+            let gt = '';
+
+            if (variant.alternateBases === ".") {
+              gt = "No Call";
+            } else {
+              const altArray = variant.alternateBases.split(",");
+
+              for (let allele of call.genotype) {
+                if (gt.length > 0) {
+                  gt += "|";
+                }
+
+                if ('.' === allele) {
+                  gt += '.';
+                } else if (allele === 0) {
+                  gt += variant.referenceBases;
+                } else {
+                  let alt = altArray[allele - 1].replace("<", "&lt;");
+                  gt += alt;
+                }
+              }
+            }
+
+            popupData.push({
+              name: 'Genotype',
+              value: gt
+            });
+          }
+
+          if (call.phaseset !== undefined) {
+            popupData.push({
+              name: 'Phase set',
+              value: call.phaseset
+            });
+          }
+
+          if (call.genotypeLikelihood !== undefined) {
+            popupData.push({
+              name: 'genotypeLikelihood',
+              value: call.genotypeLikelihood.toString()
+            });
+          }
+
+          if (sampleInformation) {
+            var attr = sampleInformation.getAttributes(call.callSetName);
+
+            if (attr) {
+              Object.keys(attr).forEach(function (attrName) {
+                var displayText = attrName.replace(/([A-Z])/g, " $1");
+                displayText = displayText.charAt(0).toUpperCase() + displayText.slice(1);
+                popupData.push({
+                  name: displayText,
+                  value: attr[attrName]
+                });
+              });
+            }
+          }
+
+          var infoKeys = Object.keys(call.info);
+
+          if (infoKeys.length) {
+            popupData.push("<hr>");
+          }
+
+          infoKeys.forEach(function (key) {
+            popupData.push({
+              name: key,
+              value: decodeURIComponent(call.info[key])
+            });
+          });
+          return popupData;
+        }
+      } // VariantTrack.prototype.contextMenuItemList = function (clickState) {
+      //
+      //     const self = this;
+      //     const menuItems = [];
+      //
+      //     const featureList = this.clickedFeatures(clickState);
+      //
+      //     if (this.callSets && featureList && featureList.length > 0) {
+      //
+      //         featureList.forEach(function (variant) {
+      //
+      //             if ('str' === variant.type) {
+      //
+      //                 menuItems.push({
+      //                     label: 'Sort by allele length',
+      //                     click: function () {
+      //                         sortCallSetsByAlleleLength(self.callSets, variant, self.sortDirection);
+      //                         self.sortDirection = (self.sortDirection === "ASC") ? "DESC" : "ASC";
+      //                         self.trackView.repaintViews();
+      //                     }
+      //                 });
+      //
+      //             }
+      //
+      //         });
+      //     }
+      //
+      //
+      //     function sortCallSetsByAlleleLength(callSets, variant, direction) {
+      //         var d = (direction === "DESC") ? 1 : -1;
+      //         Object.keys(callSets).forEach(function (property) {
+      //             callSets[property].sort(function (a, b) {
+      //                 var aNan = isNaN(variant.calls[a.id].genotype[0]);
+      //                 var bNan = isNaN(variant.calls[b.id].genotype[0]);
+      //                 if (aNan && bNan) {
+      //                     return 0;
+      //                 } else if (aNan) {
+      //                     return 1;
+      //                 } else if (bNan) {
+      //                     return -1;
+      //                 } else {
+      //                     var a0 = getAlleleString(variant.calls[a.id], variant, 0);
+      //                     var a1 = getAlleleString(variant.calls[a.id], variant, 1);
+      //                     var b0 = getAlleleString(variant.calls[b.id], variant, 0);
+      //                     var b1 = getAlleleString(variant.calls[b.id], variant, 1);
+      //                     var result = Math.max(b0.length, b1.length) - Math.max(a0.length, a1.length);
+      //                     if (result === 0) {
+      //                         result = Math.min(b0.length, b1.length) - Math.min(a0.length, a1.length);
+      //                     }
+      //                     return d * result;
+      //                 }
+      //             });
+      //         });
+      //     }
+      //
+      //
+      //     return menuItems;
+      //
+      // };
+
+
+      menuItemList() {
+        const menuItems = []; // color-by INFO attribute
+
+        if (this.header.INFO) {
+          //Code below will present checkboxes for all info fields of type "String".   Wait until this is requested
+          //const stringInfoKeys = Object.keys(this.header.INFO).filter(key => "String" === this.header.INFO[key].Type);
+          // For now stick to explicit info fields (well, exactly 1 for starters)
+          if (this.header.INFO) {
+            //const stringInfoKeys = Object.keys(this.header.INFO).filter(key => this.header.INFO[key].Type === "String")
+            const stringInfoKeys = this.header.INFO.SVTYPE ? ['SVTYPE'] : [];
+
+            if (this._initColorBy && this._initColorBy !== 'SVTYPE') {
+              stringInfoKeys.push(this._initColorBy);
+            }
+
+            if (stringInfoKeys.length > 0) {
+              const $e = $('<div class="igv-track-menu-category igv-track-menu-border-top">');
+              $e.text('Color by:');
+              menuItems.push({
+                name: undefined,
+                object: $e,
+                click: undefined,
+                init: undefined
+              });
+              stringInfoKeys.sort();
+
+              for (let item of stringInfoKeys) {
+                const selected = this.colorBy === item;
+                const label = item ? item : 'None';
+                menuItems.push(this.colorByCB({
+                  key: item,
+                  label: label
+                }, selected));
+              }
+
+              menuItems.push(this.colorByCB({
+                key: undefined,
+                label: 'None'
+              }, this.colorBy === undefined));
+            }
+          }
+        }
+
+        if (this.getCallsetsLength() > 0) {
+          menuItems.push({
+            object: $('<div class="igv-track-menu-border-top">')
+          });
+          menuItems.push({
+            object: createCheckbox$1("Show Genotypes", this.showGenotypes),
+            click: () => {
+              this.showGenotypes = !this.showGenotypes; //adjustTrackHeight();
+
+              this.trackView.checkContentHeight();
+              this.trackView.repaintViews();
+            }
+          });
+        }
+
+        menuItems.push({
+          object: $('<div class="igv-track-menu-border-top">')
+        });
+
+        for (let displayMode of ["COLLAPSED", "SQUISHED", "EXPANDED"]) {
+          var lut = {
+            "COLLAPSED": "Collapse",
+            "SQUISHED": "Squish",
+            "EXPANDED": "Expand"
+          };
+          menuItems.push({
+            object: createCheckbox$1(lut[displayMode], displayMode === this.displayMode),
+            click: () => {
+              this.displayMode = displayMode;
+              this.trackView.checkContentHeight();
+              this.trackView.repaintViews();
+            }
+          });
+        }
+
+        return menuItems;
+      }
+      /**
+       * Create a "color by" checkbox menu item, optionally initially checked
+       * @param menuItem
+       * @param showCheck
+       * @returns {{init: undefined, name: undefined, click: clickHandler, object: (jQuery|HTMLElement|jQuery.fn.init)}}
+       */
+
+
+      colorByCB(menuItem, showCheck) {
+        const $e = createCheckbox$1(menuItem.label, showCheck);
+
+        const clickHandler = ev => {
+          if (menuItem.key === this.colorBy) {
+            this.colorBy = undefined;
+            delete this.config.colorBy;
+            this.trackView.repaintViews();
+          } else {
+            this.colorBy = menuItem.key;
+            this.config.colorBy = menuItem.key;
+            this.trackView.repaintViews();
+          }
+        };
+
+        return {
+          name: undefined,
+          object: $e,
+          click: clickHandler,
+          init: undefined
+        };
+      }
+
+      getState() {
+        const config = super.getState();
+
+        if (this._color && typeof this._color !== "function") {
+          config.color = this._color;
+        }
+
+        return config;
+      }
+
+      getVariantColorTable(key) {
+        if (!this.colorTables) {
+          this.colorTables = new Map();
+        }
+
+        if (!this.colorTables.has(key)) {
+          let tbl;
+
+          switch (key) {
+            case "SVTYPE":
+              tbl = SV_COLOR_TABLE;
+              break;
+
+            default:
+              tbl = new PaletteColorTable("Set3");
+          }
+
+          this.colorTables.set(key, tbl);
+        }
+
+        return this.colorTables.get(key);
+      }
+
+    }
+
+    const SV_COLOR_TABLE = new ColorTable({
+      'DEL': '#ff2101',
+      'INS': '#001888',
+      'DUP': '#028401',
+      'INV': '#008688',
+      'CNV': '#8931ff',
+      'BND': '#891100',
+      '*': '#002eff'
+    });
+
+    /*
+     * The MIT License (MIT)
+     *
+     * Copyright (c) 2014 Broad Institute
+     *
+     * Permission is hereby granted, free of charge, to any person obtaining a copy
+     * of this software and associated documentation files (the "Software"), to deal
+     * in the Software without restriction, including without limitation the rights
+     * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+     * copies of the Software, and to permit persons to whom the Software is
+     * furnished to do so, subject to the following conditions:
+     *
+     * The above copyright notice and this permission notice shall be included in
+     * all copies or substantial portions of the Software.
+     *
+     *
+     * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+     * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+     * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+     * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+     * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+     * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+     * THE SOFTWARE.
+     */
+
+    class EqtlTrack extends TrackBase {
+      constructor(config, browser) {
+        super(config, browser);
+      }
+
+      init(config) {
+        super.init(config);
+        this.name = config.name;
+        this.pValueField = config.pValueField || "pValue";
+        this.geneField = config.geneField || "geneSymbol";
+        this.snpField = config.snpField || "snp";
+        const min = config.minLogP || config.min;
+        const max = config.maxLogP || config.max;
+        this.dataRange = {
+          min: min || 3.5,
+          max: max || 25
+        };
+
+        if (!max) {
+          this.autoscale = true;
+        } else {
+          this.autoscale = config.autoscale;
+        }
+
+        this.autoscalePercentile = config.autoscalePercentile === undefined ? 98 : config.autoscalePercentile;
+        this.background = config.background; // No default
+
+        this.divider = config.divider || "rgb(225,225,225)";
+        this.dotSize = config.dotSize || 2;
+        this.height = config.height || 100;
+        this.autoHeight = false;
+        this.disableButtons = config.disableButtons; // Limit visibility window to 2 mb,  gtex server gets flaky beyond that
+
+        this.visibilityWindow = config.visibilityWindow === undefined ? 2000000 : config.visibilityWindow >= 0 ? Math.min(2000000, config.visibilityWindow) : 2000000;
+        this.featureSource = FeatureSource(config, this.browser.genome);
+        GtexUtils.gtexLoaded = true;
+      }
+
+      paintAxis(ctx, pixelWidth, pixelHeight) {
+        const yScale = (this.dataRange.max - this.dataRange.min) / pixelHeight;
+        const font = {
+          'font': 'normal 10px Arial',
+          'textAlign': 'right',
+          'strokeStyle': "black"
+        };
+        IGVGraphics.fillRect(ctx, 0, 0, pixelWidth, pixelHeight, {
+          'fillStyle': "rgb(255, 255, 255)"
+        }); // Determine a tick spacing such that there is at least 10 pixels between ticks
+
+        const n = Math.ceil((this.dataRange.max - this.dataRange.min) * 10 / pixelHeight);
+
+        for (let p = 4; p <= this.dataRange.max; p += n) {
+          // TODO: Dashes may not actually line up with correct scale. Ask Jim about this
+          const ref = 0.85 * pixelWidth;
+          const x1 = ref - 5;
+          const x2 = ref;
+          const y = pixelHeight - (p - this.dataRange.min) / yScale;
+          IGVGraphics.strokeLine(ctx, x1, y, x2, y, font); // Offset dashes up by 2 pixel
+
+          if (y > 8) {
+            IGVGraphics.fillText(ctx, p, x1 - 1, y + 2, font);
+          } // Offset numbers down by 2 pixels;
+
+        }
+
+        font['textAlign'] = 'center';
+        IGVGraphics.fillText(ctx, "-log10(pvalue)", pixelWidth / 4, pixelHeight / 2, font, {
+          rotate: {
+            angle: -90
+          }
+        });
+      }
+
+      async getFeatures(chr, start, end) {
+        const pValueField = this.pValueField;
+        const features = await this.featureSource.getFeatures({
+          chr,
+          start,
+          end
+        });
+        features.forEach(function (f) {
+          f.value = f[pValueField];
+        });
+        return features;
+      }
+
+      draw(options) {
+        const ctx = options.context;
+        const pixelWidth = options.pixelWidth;
+        const pixelHeight = options.pixelHeight;
+
+        if (this.background) {
+          IGVGraphics.fillRect(ctx, 0, 0, pixelWidth, pixelHeight, {
+            'fillStyle': this.background
+          });
+        }
+
+        IGVGraphics.strokeLine(ctx, 0, pixelHeight - 1, pixelWidth, pixelHeight - 1, {
+          'strokeStyle': this.divider
+        });
+        ctx.save();
+
+        const drawEqtls = drawSelected => {
+          const radius = drawSelected ? 2 * this.dotSize : this.dotSize;
+          const bpStart = options.bpStart;
+          const yScale = (this.dataRange.max - this.dataRange.min) / pixelHeight;
+          const selection = options.referenceFrame.selection;
+
+          for (let eqtl of options.features) {
+            const px = (eqtl.start - bpStart + 0.5) / options.bpPerPixel;
+            if (px < 0) continue;else if (px > pixelWidth) break;
+            const snp = eqtl.snp.toUpperCase();
+            const geneName = eqtl[this.geneField].toUpperCase();
+            const isSelected = selection && (selection.snp === snp || selection.gene === geneName);
+
+            if (!drawSelected || isSelected) {
+              // Add eqtl's gene to the selection if this is the selected snp.
+              // TODO -- this should not be done here in the rendering code.
+              if (selection && selection.snp === snp) {
+                selection.addGene(geneName);
+              }
+
+              var mLogP = -Math.log(eqtl[this.pValueField]) / Math.LN10;
+
+              if (mLogP >= this.dataRange.min) {
+                let capped;
+
+                if (mLogP > this.dataRange.max) {
+                  mLogP = this.dataRange.max;
+                  capped = true;
+                } else {
+                  capped = false;
+                }
+
+                const py = Math.max(0 + radius, pixelHeight - Math.round((mLogP - this.dataRange.min) / yScale));
+                eqtl.px = px;
+                eqtl.py = py;
+                eqtl.radius = radius;
+                let color;
+
+                if (drawSelected && selection) {
+                  color = selection.colorForGene(geneName);
+                  IGVGraphics.setProperties(ctx, {
+                    fillStyle: color,
+                    strokeStyle: "black"
+                  });
+                } else {
+                  color = capped ? "rgb(150, 150, 150)" : "rgb(180, 180, 180)";
+                  IGVGraphics.setProperties(ctx, {
+                    fillStyle: color,
+                    strokeStyle: color
+                  });
+                }
+
+                IGVGraphics.fillCircle(ctx, px, py, radius);
+                IGVGraphics.strokeCircle(ctx, px, py, radius);
+              }
+            }
+          }
+        }; // Draw in two passes, with "selected" eqtls drawn last
+
+
+        drawEqtls(false);
+        drawEqtls(true);
+        ctx.restore();
+      }
+      /**
+       * Return "popup data" for feature @ genomic location.  Data is an array of key-value pairs
+       */
+
+
+      popupData(clckState) {
+        let features = clckState.viewport.getCachedFeatures();
+        if (!features || features.length === 0) return [];
+        const tolerance = 3;
+        const tissue = this.name;
+        const popupData = [];
+
+        for (let feature of features) {
+          // Hit test --use square vs circle for efficiency (no sqrt)
+          if (Math.abs(feature.px - clckState.canvasX) < feature.radius + tolerance && Math.abs(feature.py - clckState.canvasY) < feature.radius + tolerance) {
+            if (popupData.length > 0) {
+              popupData.push("<hr>");
+            }
+
+            popupData.push({
+              name: "snp id",
+              value: feature.snp
+            }, {
+              name: "gene id",
+              value: feature.geneId
+            }, {
+              name: "gene name",
+              value: feature.geneName
+            }, {
+              name: "p value",
+              value: feature.pValue
+            }, {
+              name: "tissue",
+              value: tissue
+            });
+          }
+        }
+
+        return popupData;
+      }
+
+      menuItemList() {
+        return MenuUtils.numericDataMenuItems(this.trackView);
+      }
+
+      doAutoscale(featureList) {
+        if (featureList.length > 0) {
+          var values = featureList.map(function (eqtl) {
+            return -Math.log(eqtl.value) / Math.LN10;
+          });
+          this.dataRange.max = IGVMath.percentile(values, this.autoscalePercentile);
+        } else {
+          // No features -- default
+          const max = this.config.maxLogP || this.config.max;
+          this.dataRange.max = max || 25;
+        }
+
+        return this.dataRange;
+      }
+
+    }
+
+    /**
+     * Colors used for coding omosomes
+     */
+    const Colors = {
+      "X": "rgb(204, 153, 0)",
+      "Y": "rgb(153, 204, 0)",
+      "Un": "darkGray)",
+      "1": "rgb(80, 80, 255)",
+      //"1": Color.red);
+      "I": "rgb(139, 155, 187)",
+      "2": "rgb(206, 61, 50)",
+      "II": "rgb(206, 61, 50)",
+      "2a": "rgb(210, 65, 55)",
+      "2b": "rgb(215, 70, 60)",
+      "3": "rgb(116, 155, 88)",
+      "III": "rgb(116, 155, 88)",
+      "4": "rgb(240, 230, 133)",
+      "IV": "rgb(240, 230, 133)",
+      "5": "rgb(70, 105, 131)",
+      "6": "rgb(186, 99, 56)",
+      "7": "rgb(93, 177, 221)",
+      "8": "rgb(128, 34, 104)",
+      "9": "rgb(107, 215, 107)",
+      "10": "rgb(213, 149, 167)",
+      "11": "rgb(146, 72, 34)",
+      "12": "rgb(131, 123, 141)",
+      "13": "rgb(199, 81, 39)",
+      "14": "rgb(213, 143, 92)",
+      "15": "rgb(122, 101, 165)",
+      "16": "rgb(228, 175, 105)",
+      "17": "rgb(59, 27, 83)",
+      "18": "rgb(205, 222, 183)",
+      "19": "rgb(97, 42, 121)",
+      "20": "rgb(174, 31, 99)",
+      "21": "rgb(231, 199, 111)",
+      "22": "rgb(90, 101, 94)",
+      "23": "rgb(204, 153, 0)",
+      "24": "rgb(153, 204, 0)",
+      "25": "rgb(51, 204, 0)",
+      "26": "rgb(0, 204, 51)",
+      "27": "rgb(0, 204, 153)",
+      "28": "rgb(0, 153, 204)",
+      "29": "rgb(10, 71, 255)",
+      "30": "rgb(71, 117, 255)",
+      "31": "rgb(255, 194, 10)",
+      "32": "rgb(255, 209, 71)",
+      "33": "rgb(153, 0, 51)",
+      "34": "rgb(153, 26, 0)",
+      "35": "rgb(153, 102, 0)",
+      "36": "rgb(128, 153, 0)",
+      "37": "rgb(51, 153, 0)",
+      "38": "rgb(0, 153, 26)",
+      "39": "rgb(0, 153, 102)",
+      "40": "rgb(0, 128, 153)",
+      "41": "rgb(0, 51, 153)",
+      "42": "rgb(26, 0, 153)",
+      "43": "rgb(102, 0, 153)",
+      "44": "rgb(153, 0, 128)",
+      "45": "rgb(214, 0, 71)",
+      "46": "rgb(255, 20, 99)",
+      "47": "rgb(0, 214, 143)",
+      "48": "rgb(20, 255, 177)"
+    }; //  aliasing
+
+    for (let key of Object.keys(Colors)) {
+      const altName = "chr" + key;
+      Colors[altName] = Colors[key];
+    }
+
+    /*
+     * The MIT License (MIT)
+     *
+     * Copyright (c) 2014 Broad Institute
+     *
+     * Permission is hereby granted, free of charge, to any person obtaining a copy
+     * of this software and associated documentation files (the "Software"), to deal
+     * in the Software without restriction, including without limitation the rights
+     * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+     * copies of the Software, and to permit persons to whom the Software is
+     * furnished to do so, subject to the following conditions:
+     *
+     * The above copyright notice and this permission notice shall be included in
+     * all copies or substantial portions of the Software.
+     *
+     *
+     * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+     * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+     * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+     * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+     * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+     * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+     * THE SOFTWARE.
+     */
+    const DEFAULT_POPOVER_WINDOW = 100000000; //const type = "gwas";
+
+    class GWASTrack extends TrackBase {
+      constructor(config, browser) {
+        super(config, browser);
+      }
+
+      init(config) {
+        super.init(config);
+        this.useChrColors = config.useChrColors === undefined ? true : config.useChrColors;
+        this.trait = config.trait;
+        this.posteriorProbability = config.posteriorProbability;
+        this.height = config.height || 100; // The preferred height
+        // Set initial range if specfied, unless autoscale == true
+
+        if (!config.autoscale) {
+          if (config.posteriorProbability) {
+            this.dataRange = {
+              min: config.min === undefined ? 0 : config.min,
+              max: config.max === undefined ? 1 : config.max
+            };
+          } else {
+            this.dataRange = {
+              min: config.min === undefined ? 0 : config.min,
+              max: config.max === undefined ? 25 : config.max
+            };
+          }
+        }
+
+        this.autoscale = config.autoscale;
+        this.autoscalePercentile = config.autoscalePercentile === undefined ? 98 : config.autoscalePercentile;
+        this.background = config.background; // No default
+
+        this.divider = config.divider || "rgb(225,225,225)";
+        this.dotSize = config.dotSize || 3;
+        this.popoverWindow = config.popoverWindow === undefined ? DEFAULT_POPOVER_WINDOW : config.popoverWindow;
+        this.description = config.description; // might be null
+
+        this.colorScales = config.color ? new ConstantColorScale(config.color) : {
+          "*": new BinnedColorScale(config.colorScale || {
+            thresholds: [5e-8, 5e-4, 0.5],
+            colors: ["rgb(255,50,50)", "rgb(251,100,100)", "rgb(251,170,170)", "rgb(227,238,249)"]
+          })
+        };
+        this.featureSource = FeatureSource(config, this.browser.genome);
+      }
+
+      supportsWholeGenome() {
+        return true;
+      }
+
+      async getFeatures(chr, start, end) {
+        return this.featureSource.getFeatures({
+          chr,
+          start,
+          end
+        });
+      }
+
+      draw(options) {
+        const featureList = options.features;
+        const ctx = options.context;
+        const pixelWidth = options.pixelWidth;
+        const pixelHeight = options.pixelHeight;
+
+        if (this.background) {
+          IGVGraphics.fillRect(ctx, 0, 0, pixelWidth, pixelHeight, {
+            'fillStyle': this.background
+          });
+        }
+
+        IGVGraphics.strokeLine(ctx, 0, pixelHeight - 1, pixelWidth, pixelHeight - 1, {
+          'strokeStyle': this.divider
+        });
+
+        if (featureList) {
+          const bpPerPixel = options.bpPerPixel;
+          const bpStart = options.bpStart;
+          const bpEnd = bpStart + pixelWidth * bpPerPixel + 1;
+
+          for (let variant of featureList) {
+            const pos = variant.start;
+            if (pos < bpStart) continue;
+            if (pos > bpEnd) break;
+            const colorScale = this.getColorScale(variant._f ? variant._f.chr : variant.chr);
+            let color;
+            let val;
+
+            if (this.posteriorProbability) {
+              val = variant.value;
+              color = colorScale.getColor(val);
+            } else {
+              const pvalue = variant.value || variant.score;
+              if (!pvalue) continue;
+              val = -Math.log10(pvalue);
+              color = colorScale.getColor(val);
+            }
+
+            const yScale = (this.dataRange.max - this.dataRange.min) / pixelHeight;
+            const px = Math.round((pos - bpStart) / bpPerPixel);
+            const py = Math.max(this.dotSize, pixelHeight - Math.round((val - this.dataRange.min) / yScale));
+
+            if (color) {
+              IGVGraphics.setProperties(ctx, {
+                fillStyle: color,
+                strokeStyle: "black"
+              });
+            }
+
+            IGVGraphics.fillCircle(ctx, px, py, this.dotSize);
+            variant.px = px;
+            variant.py = py;
+          }
+        }
+      }
+
+      getColorScale(chr) {
+        if (this.useChrColors) {
+          let cs = this.colorScales[chr];
+
+          if (!cs) {
+            const color = Colors[chr] || randomColor();
+            cs = new ConstantColorScale(color);
+            this.colorScales[chr] = cs;
+          }
+
+          return cs;
+        } else {
+          return this.colorScales("*");
+        }
+      }
+
+      paintAxis(ctx, pixelWidth, pixelHeight) {
+        IGVGraphics.fillRect(ctx, 0, 0, pixelWidth, pixelHeight, {
+          'fillStyle': "rgb(255, 255, 255)"
+        });
+        var font = {
+          'font': 'normal 10px Arial',
+          'textAlign': 'right',
+          'strokeStyle': "black"
+        };
+        const yScale = (this.dataRange.max - this.dataRange.min) / pixelHeight;
+
+        if (this.posteriorProbability) {
+          const n = 0.1;
+
+          for (let p = this.dataRange.min; p < this.dataRange.max; p += n) {
+            const yp = pixelHeight - Math.round((p - this.dataRange.min) / yScale);
+            IGVGraphics.strokeLine(ctx, 45, yp - 2, 50, yp - 2, font); // Offset dashes up by 2 pixel
+
+            IGVGraphics.fillText(ctx, p.toFixed(1), 44, yp + 2, font); // Offset numbers down by 2 pixels;
+          }
+        } else {
+          const n = Math.ceil((this.dataRange.max - this.dataRange.min) * 10 / pixelHeight);
+
+          for (let p = this.dataRange.min; p < this.dataRange.max; p += n) {
+            const yp = pixelHeight - Math.round((p - this.dataRange.min) / yScale);
+            IGVGraphics.strokeLine(ctx, 45, yp, 50, yp, font); // Offset dashes up by 2 pixel
+
+            IGVGraphics.fillText(ctx, Math.floor(p), 44, yp + 4, font); // Offset numbers down by 2 pixels;
+          }
+        }
+
+        font['textAlign'] = 'center';
+
+        if (this.posteriorProbability) {
+          IGVGraphics.fillText(ctx, "PPA", pixelWidth / 2, pixelHeight / 2, font, {
+            rotate: {
+              angle: -90
+            }
+          });
+        } else {
+          IGVGraphics.fillText(ctx, "-log10(pvalue)", pixelWidth / 2, pixelHeight / 2, font, {
+            rotate: {
+              angle: -90
+            }
+          });
+        }
+      }
+
+      popupData(clickState) {
+        let data = [];
+        const track = clickState.viewport.trackView.track;
+        const features = clickState.viewport.getCachedFeatures();
+
+        if (features) {
+          let count = 0;
+
+          for (let f of features) {
+            const xDelta = Math.abs(clickState.canvasX - f.px);
+            const yDelta = Math.abs(clickState.canvasY - f.py);
+            const value = f.value || f.score;
+
+            if (xDelta < this.dotSize && yDelta < this.dotSize) {
+              if (count > 0) {
+                data.push("<HR/>");
+              }
+
+              if (count == 5) {
+                data.push("...");
+                break;
+              }
+
+              if (typeof f.popupData === 'function') {
+                data = data.concat(f.popupData());
+              } else {
+                const chr = f.realChr || f.chr;
+                const pos = (f.realStart || f.start) + 1;
+                data.push({
+                  name: 'chromosome',
+                  value: chr
+                });
+                data.push({
+                  name: 'position',
+                  value: pos
+                });
+                data.push({
+                  name: 'name',
+                  value: f.name
+                });
+
+                if (track.posteriorProbability) {
+                  data.push({
+                    name: 'posterior probability',
+                    value: value
+                  });
+                } else {
+                  data.push({
+                    name: 'pValue',
+                    value: value
+                  });
+                }
+              }
+
+              count++;
+            }
+          }
+        }
+
+        return data;
+      }
+
+      menuItemList() {
+        return MenuUtils.numericDataMenuItems(this.trackView);
+      }
+
+      doAutoscale(featureList) {
+        if (featureList.length > 0) {
+          // posterior probabilities are treated without modification, but we need to take a negative logarithm of P values
+          const features = this.posteriorProbability ? featureList : featureList.map(function (feature) {
+            const v = feature.value !== undefined ? feature.value : feature.score;
+            return {
+              value: -Math.log(v) / Math.LN10
+            };
+          });
+          const range = doAutoscale(features);
+          this.dataRange.max = range.max;
+          this.dataRange.min = range.min !== range.max ? range.min : 0;
+        } else {
+          // No features -- pick something reasonable for PPAs and p-values
+          if (this.posteriorProbability) {
+            this.dataRange.min = this.config.min || 0;
+            this.dataRange.max = this.config.max || 1;
+          } else {
+            this.dataRange.max = this.config.max || 25;
+            this.dataRange.min = this.config.min || 0;
+          }
+        }
+
+        return this.dataRange;
+      }
+
+    }
+
+    const X_PIXEL_DIFF_THRESHOLD = 1;
+
+    class GCNVTrack extends TrackBase {
+      constructor(config, browser) {
+        super(config, browser);
+      }
+
+      init(config) {
+        super.init(config);
+        this.autoscale = config.autoscale || config.max === undefined;
+        this.dataRange = {
+          min: config.min || 0,
+          max: config.max
+        };
+        this.windowFunction = config.windowFunction || "mean";
+        this.paintAxis = paintAxis;
+        this.graphType = config.graphType || "bar"; //hack to avoid creating feature source multiple times.  If config.type is not set the file must be read
+        //to determine type, which results in creation of a feature source.
+
+        if (config._featureSource) {
+          this.featureSource = config._featureSource;
+          delete config._featureSource;
+        } else {
+          this.featureSource = FeatureSource(this.config, this.browser.genome);
+        }
+      }
+
+      async postInit() {
+        if (typeof this.featureSource.getHeader === "function") {
+          this.header = await this.featureSource.getHeader();
+          this.sampleNames = this.header.columnNames.slice(3); // Set generic properties from track line
+
+          this.setTrackProperties(this.header); // setTrackProperties defined in TrackBase
+          // Special track line properties
+
+          if (this.header.hasOwnProperty("highlight")) {
+            this.config.highlightSamples = {};
+            let v = this.header["highlight"];
+            if (!Array.isArray(v)) v = [v];
+
+            for (let h of v) {
+              const tokens = h.split(";");
+
+              if (tokens.length === 2) {
+                this.config.highlightSamples[tokens[0]] = tokens[1];
+              }
+            }
+          }
+        }
+      }
+
+      menuItemList() {
+        return MenuUtils.numericDataMenuItems(this.trackView);
+      }
+
+      async getFeatures(chr, start, end) {
+        const chrFeatures = await this.featureSource.getFeatures({
+          chr,
+          start: 0,
+          end: Number.MAX_VALUE
+        });
+        let prevIndex = undefined;
+        let nextIndex = undefined;
+
+        for (let i = 1; i < chrFeatures.length - 1; i++) {
+          if (prevIndex === undefined && chrFeatures[i].end > start) {
+            prevIndex = i - 1;
+          }
+
+          if (nextIndex === undefined && chrFeatures[i].start > end) {
+            nextIndex = i + 1;
+            break;
+          }
+        }
+
+        if (prevIndex === undefined) prevIndex = 0;
+        if (nextIndex === undefined) nextIndex = chrFeatures.length;
+        return chrFeatures.slice(prevIndex, nextIndex);
+      }
+
+      draw(options) {
+        const {
+          features,
+          context,
+          bpPerPixel,
+          bpStart,
+          pixelWidth,
+          pixelHeight
+        } = options; ///let baselineColor;
+        //if (typeof self.color === "string" && self.color.startsWith("rgb(")) {
+        //    baselineColor = IGVColor.addAlpha(self.color, 0.1);
+        //}
+
+        const yScale = yValue => {
+          return (this.dataRange.max - yValue) / (this.dataRange.max - this.dataRange.min) * pixelHeight;
+        };
+
+        const getX = function (bpPosition) {
+          let x = Math.floor((bpPosition - bpStart) / bpPerPixel);
+          if (isNaN(x)) console.warn('isNaN(x). feature start ' + numberFormatter$1(bpPosition) + ' bp start ' + numberFormatter$1(bpStart));
+          return x;
+        };
+
+        const drawGuideLines = options => {
+          if (this.config.hasOwnProperty('guideLines')) {
+            for (let line of this.config.guideLines) {
+              if (line.hasOwnProperty('color') && line.hasOwnProperty('y') && line.hasOwnProperty('dotted')) {
+                let y = yScale(line.y);
+                let props = {
+                  'strokeStyle': line['color'],
+                  'strokeWidth': 2
+                };
+                if (line['dotted']) IGVGraphics.dashedLine(options.context, 0, y, options.pixelWidth, y, 5, props);else IGVGraphics.strokeLine(options.context, 0, y, options.pixelWidth, y, props);
+              }
+            }
+          }
+        };
+
+        if (features && features.length > 0) {
+          if (this.dataRange.min === undefined) this.dataRange.min = 0; // Max can be less than min if config.min is set but max left to autoscale. If that's the case there is
+          // nothing to paint.
+
+          if (this.dataRange.max > this.dataRange.min) {
+            const highlightSamples = this.config.highlightSamples;
+            const onlyHandleClicksForHighlightedSamples = this.config.onlyHandleClicksForHighlightedSamples;
+            let previousEnd = -1;
+            let previousValues = {};
+            let highlightConnectorLines = [];
+            let highlightFeatureLines = []; // clickDetectorCache allows fast retrieval of whether a mouse click hits a rendered line segment
+            // by storing lists of rendered line segments, keyed by their right x coordinate in canvas pixel space.
+            // this cache is regenerated on every draw.
+
+            this.clickDetectorCache = {};
+
+            for (let feature of features) {
+              const x1 = getX(feature.start);
+              const x2 = getX(feature.end);
+              const previousX = previousEnd >= 0 ? getX(previousEnd) : x1;
+              if (isNaN(x1) || isNaN(x2)) continue;
+              if (x1 - previousX < X_PIXEL_DIFF_THRESHOLD && x2 - x1 < X_PIXEL_DIFF_THRESHOLD) continue;
+              this.clickDetectorCache[x1] = [];
+              this.clickDetectorCache[x2] = [];
+
+              for (let i = 0; i < feature.values.length; i++) {
+                const sampleName = this.sampleNames[i];
+                const value = feature.values[i];
+                const y = yScale(value);
+
+                if (x1 - previousX >= X_PIXEL_DIFF_THRESHOLD) {
+                  const previousValue = previousValues[sampleName];
+                  const previousY = yScale(previousValue);
+                  const highlightColor = highlightSamples && highlightSamples[sampleName];
+
+                  if (highlightColor) {
+                    highlightConnectorLines.push([previousX, previousY, x1, y, highlightColor]);
+                  } else {
+                    IGVGraphics.strokeLine(context, previousX, previousY, x1, y, {
+                      strokeStyle: '#D9D9D9'
+                    });
+                  }
+
+                  if (!onlyHandleClicksForHighlightedSamples || sampleName in highlightSamples) {
+                    this.clickDetectorCache[x1].push([previousX, previousY, x1, y, sampleName, highlightColor || 'gray']);
+                  }
+                }
+
+                if (x2 - x1 >= X_PIXEL_DIFF_THRESHOLD) {
+                  const highlightColor = highlightSamples && highlightSamples[sampleName];
+
+                  if (highlightColor) {
+                    highlightFeatureLines.push([x1, y, x2, y, highlightColor]);
+                  } else {
+                    IGVGraphics.strokeLine(context, x1, y, x2, y, {
+                      strokeStyle: 'gray'
+                    });
+                  }
+
+                  if (!onlyHandleClicksForHighlightedSamples || sampleName in highlightSamples) {
+                    this.clickDetectorCache[x2].push([x1, y, x2, y, sampleName, highlightColor || 'gray']);
+                  }
+                }
+
+                previousValues[sampleName] = value; //IGVGraphics.fillCircle(ctx, px, y, pointSize / 2, {"fillStyle": color, "strokeStyle": color});
+                //IGVGraphics.fillRect(ctx, x, y, width, height, {fillStyle: color});
+              }
+
+              previousEnd = feature.end;
+            }
+
+            for (let f of highlightConnectorLines) {
+              IGVGraphics.strokeLine(context, f[0], f[1], f[2], f[3], {
+                strokeStyle: f[4],
+                lineWidth: 1.3
+              });
+            }
+
+            for (let f of highlightFeatureLines) {
+              IGVGraphics.strokeLine(context, f[0], f[1], f[2], f[3], {
+                strokeStyle: f[4],
+                lineWidth: 2
+              });
+            }
+            /*
+            // If the track includes negative values draw a baseline
+            if (this.dataRange.min < 0) {
+                const basepx = (self.dataRange.max / (this.dataRange.max - this.dataRange.min)) * options.pixelHeight;
+                IGVGraphics.strokeLine(context, 0, basepx, options.pixelWidth, basepx, {strokeStyle: baselineColor});
+            }
+            */
+
+          }
+        }
+
+        drawGuideLines(options);
+      }
+
+      doAutoscale(features) {
+        let min, max;
+
+        if (features.length > 0) {
+          min = Number.MAX_VALUE;
+          max = -Number.MAX_VALUE;
+          features.forEach(function (feature) {
+            min = Math.min(min, ...feature.values);
+            max = Math.max(max, ...feature.values);
+          });
+          min -= 0.01;
+          max += 0.01;
+        } else {
+          // No features -- default
+          min = 0;
+          max = 100;
+        }
+
+        return {
+          min: min,
+          max: max
+        };
+      }
+
+      clickedFeatures(clickState) {
+        //console.warn('click', clickState.canvasX, clickState.canvasY, clickState)
+        const BOUNDING_BOX_PADDING = 10;
+        const MIN_DISTANCE_TO_SEGMENT = 5;
+        const clickX = clickState.canvasX;
+        const clickY = clickState.canvasY;
+        let key = null;
+
+        for (key of Object.keys(this.clickDetectorCache)) {
+          key = parseInt(key);
+
+          if (key >= clickX) {
+            break;
+          }
+        }
+
+        if (key) {
+          let closestDistanceSoFar = Number.MAX_VALUE;
+          let closestResult = [];
+          const segments = this.clickDetectorCache[key];
+
+          for (let segment of segments) {
+            const x1 = segment[0];
+            const x2 = segment[2];
+            if (clickX < x1 || clickX > x2) return [];
+            const y1 = segment[1];
+            const y2 = segment[3];
+            if (clickY < Math.min(y1, y2) - BOUNDING_BOX_PADDING || clickY > Math.max(y1, y2) + BOUNDING_BOX_PADDING) continue;
+            const distance = distanceToLine(clickX, clickY, x1, y1, x2, y2);
+
+            if (distance < closestDistanceSoFar) {
+              closestResult = [{
+                'name': segment[4],
+                'color': segment[5]
+              }];
+              closestDistanceSoFar = distance; //console.warn('closest:', 'name', segment[4], 'color', segment[5], distance);
+            }
+          }
+
+          if (closestDistanceSoFar < MIN_DISTANCE_TO_SEGMENT) {
+            return closestResult;
+          }
+        }
+
+        return [];
+      }
+
+      popupData(clickState, featureList) {
+        featureList = this.clickedFeatures(clickState, featureList);
+        const items = [];
+        featureList.forEach(function (f) {
+          for (let property of Object.keys(f)) {
+            if (isSimpleType(f[property])) {
+              items.push({
+                name: property,
+                value: f[property]
+              });
+            }
+          }
+        });
+        return items;
+      }
+
+      supportsWholeGenome() {
+        return false;
+      }
+
+    }
+
+    function distanceToLine(x, y, ax, ay, bx, by) {
+      /*
+          Finds distance between point (x, y) and line defined by points (ax, ay) (bx, by)
+          based on http://mathworld.wolfram.com/Point-LineDistance2-Dimensional.html
+      */
+      const bx_minus_ax = bx - ax;
+      const by_minus_ay = by - ay;
+      const v = Math.abs(bx_minus_ax * (ay - y) - (ax - x) * by_minus_ay);
+      const r = Math.sqrt(bx_minus_ax * bx_minus_ax + by_minus_ay * by_minus_ay);
+      const distance = r > 0 ? v / r : 0; //console.warn('Check if', x, y, 'is within', ax, ay, bx, by, '. Distance from line: ', distance);
+
+      return distance;
+    }
+
+    /*
+     * The MIT License (MIT)
+     *
+     * Copyright (c) 2014 Broad Institute
+     *
+     * Permission is hereby granted, free of charge, to any person obtaining a copy
+     * of this software and associated documentation files (the "Software"), to deal
+     * in the Software without restriction, including without limitation the rights
+     * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+     * copies of the Software, and to permit persons to whom the Software is
+     * furnished to do so, subject to the following conditions:
+     *
+     * The above copyright notice and this permission notice shall be included in
+     * all copies or substantial portions of the Software.
+     *
+     *
+     * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+     * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+     * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+     * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+     * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+     * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+     * THE SOFTWARE.
+     */
+
+    class RnaStructTrack extends TrackBase {
+      constructor(config, browser) {
+        super(config, browser); // Set defaults
+
+        if (!config.height) {
+          this.height = 300;
+        }
+
+        this.arcOrientation = false;
+        this.theta = Math.PI / 2;
+
+        if ("bp" === config.format) {
+          this.featureSource = new RNAFeatureSource(config, browser.genome);
+        } else {
+          this.featureSource = new RNAFeatureSource(config, browser.genome);
+        }
+      }
+
+      async getFeatures(chr, start, end) {
+        return this.featureSource.getFeatures(chr, start, end);
+      }
+
+      draw(options) {
+        const self = this;
+        const theta = Math.PI / 2;
+        const ctx = options.context;
+        const pixelWidth = options.pixelWidth;
+        const pixelHeight = options.pixelHeight;
+        options.viewportWidth;
+        const bpPerPixel = options.bpPerPixel;
+        const bpStart = options.bpStart;
+        const xScale = bpPerPixel;
+        const orienation = self.arcOrientation;
+        IGVGraphics.fillRect(ctx, 0, options.pixelTop, pixelWidth, pixelHeight, {
+          'fillStyle': "rgb(255, 255, 255)"
+        });
+        const featureList = options.features;
+
+        if (featureList) {
+          // Sort by score -- draw lowest scored features first
+          sortByScore(featureList, 1);
+          featureList.forEach(function (feature) {
+            if (feature.startLeft) {
+              let sl = Math.round((feature.startLeft - bpStart) / xScale);
+              let sr = Math.round((feature.startRight - bpStart) / xScale);
+              let el = Math.round((feature.endLeft - bpStart) / xScale);
+              let er = Math.round((feature.endRight - bpStart) / xScale);
+              ctx.fillStyle = feature.color;
+              ctx.strokeStyle = feature.color;
+              ctx.beginPath(); // First arc
+
+              let x1 = (sl + er) / 2;
+              let r1 = (er - sl) / 2;
+              let y1 = self.height;
+              let sa = Math.PI + (Math.PI / 2 - theta);
+              let ea = 2 * Math.PI - (Math.PI / 2 - theta);
+
+              if (orienation) {
+                y1 = 0;
+                ctx.arc(x1, y1, r1, ea, sa);
+                ctx.lineTo(er, y1);
+              } else {
+                ctx.arc(x1, y1, r1, sa, ea);
+                ctx.lineTo(el, y1);
+              } // Second arc
+
+
+              const x2 = (sr + el) / 2;
+              const r2 = (el - sr) / 2;
+              const y2 = y1; // Only for theta == pi/2
+
+              if (orienation) {
+                ctx.arc(x2, y2, r2, sa, ea, true);
+                ctx.lineTo(el, y2);
+              } else {
+                ctx.arc(x2, y2, r2, ea, sa, true);
+                ctx.lineTo(sl, y2);
+              }
+
+              ctx.stroke();
+              ctx.fill();
+              feature.drawState = {
+                x1: x1,
+                y1: y1,
+                r1: r1,
+                x2: x2,
+                y2: y2,
+                r2: r2,
+                sa: sa,
+                ea: ea
+              };
+            } else {
+              let s = Math.round((feature.start - bpStart) / xScale);
+              let e = Math.round((feature.end - bpStart) / xScale);
+              ctx.strokeStyle = feature.color;
+              ctx.beginPath(); // First arc
+
+              let x = (s + e) / 2;
+              let r = (e - s) / 2;
+              let y = self.height;
+              let sa = Math.PI + (Math.PI / 2 - theta);
+              let ea = 2 * Math.PI - (Math.PI / 2 - theta);
+
+              if (orienation) {
+                y = 0;
+                ctx.arc(x, y, r, ea, sa);
+              } else {
+                ctx.arc(x, y, r, sa, ea);
+              }
+
+              ctx.stroke();
+              feature.drawState = {
+                x1: x,
+                y1: y,
+                r1: r,
+                sa: sa,
+                ea: ea
+              };
+            }
+          });
+        }
+      }
+
+      clickedFeatures(clickState, features) {
+        features = super.clickedFeatures(clickState, features);
+        const clicked = []; // Sort by score in descending order   (opposite order than drawn)
+
+        sortByScore(features, -1);
+
+        for (let f of features) {
+          const ds = f.drawState; // Distance from arc radius, or outer arc for type ".bp"
+
+          const dx1 = clickState.canvasX - ds.x1;
+          const dy1 = clickState.canvasY - ds.y1;
+          const d1 = Math.sqrt(dx1 * dx1 + dy1 * dy1);
+          const outerLim = ds.r1 + 3;
+          let d2;
+          let innerLim;
+
+          if (ds.x2 === undefined) {
+            d2 = d1;
+            innerLim = ds.r1 - 3;
+          } else {
+            const dx2 = clickState.canvasX - ds.x2;
+            const dy2 = clickState.canvasY - ds.y2;
+            d2 = Math.sqrt(dx2 * dx2 + dy2 * dy2);
+            innerLim = ds.r2 - 3;
+          } // Between outer and inner arcs, with some tolerance
+
+
+          if (d1 < outerLim && d2 > innerLim) {
+            clicked.push(f);
+            break;
+          }
+        }
+
+        return clicked;
+      }
+
+      popupData(clickState, features) {
+        // We use the featureCache property rather than method to avoid async load.  If the
+        // feature is not already loaded this won't work,  but the user wouldn't be mousing over it either.
+        features = this.clickedFeatures(clickState, features);
+
+        if (features && features.length > 0) {
+          return TrackBase.extractPopupData(features[0], this.getGenomeId());
+        }
+      }
+
+      menuItemList() {
+        var self = this;
+        return [{
+          name: "Toggle arc direction",
+          click: function () {
+            self.arcOrientation = !self.arcOrientation;
+            self.trackView.repaintViews();
+          }
+        }];
+      }
+
+    }
+
+    function sortByScore(featureList, direction) {
+      featureList.sort(function (a, b) {
+        const s1 = a.score === undefined ? -Number.MAX_VALUE : a.score;
+        const s2 = b.score === undefined ? -Number.MAX_VALUE : b.score;
+        const d = direction === undefined ? 1 : direction;
+        return d * (s1 - s2);
+      });
+    }
+
+    class RNAFeatureSource {
+      constructor(config, genome) {
+        this.config = config;
+        this.genome = genome;
+      }
+
+      async getFeatures(chr, start, end) {
+        const genome = this.genome;
+
+        if (!this.featureCache) {
+          const options = buildOptions(this.config);
+          const data = await igvxhr.loadString(this.config.url, options);
+          this.featureCache = new FeatureCache(parseBP(data), genome);
+          return this.featureCache.queryFeatures(chr, start, end);
+        } else {
+          return this.featureCache.queryFeatures(chr, start, end);
+        }
+
+        function parseBP(data) {
+          if (!data) return null;
+          const dataWrapper = getDataWrapper(data);
+          let header = true;
+          let line;
+          const colors = [];
+          const descriptors = [];
+          const features = [];
+
+          while ((line = dataWrapper.nextLine()) !== undefined) {
+            const tokens = line.split('\t');
+
+            if (header && line.startsWith("color:")) {
+              const color = "rgb(" + tokens[1] + "," + tokens[2] + "," + tokens[3] + ")";
+              colors.push(color);
+
+              if (tokens.length > 4) {
+                descriptors.push(tokens[4]);
+              } // TODO - use label
+
+            } else {
+              header = false;
+              const chr = tokens[0];
+              const startLeftNuc = Number.parseInt(tokens[1]) - 1;
+              const startRightNuc = Number.parseInt(tokens[2]) - 1;
+              const endLeftNuc = Number.parseInt(tokens[3]);
+              const endRightNuc = Number.parseInt(tokens[4]);
+              var colorIdx = Number.parseInt(tokens[5]);
+              const color = colors[colorIdx];
+              let feature;
+
+              if (startLeftNuc <= endRightNuc) {
+                feature = {
+                  chr: chr,
+                  startLeft: Math.min(startLeftNuc, startRightNuc),
+                  startRight: Math.max(startLeftNuc, startRightNuc),
+                  endLeft: Math.min(endLeftNuc, endRightNuc),
+                  endRight: Math.max(endLeftNuc, endRightNuc),
+                  color: color,
+                  score: colorIdx
+                };
+              } else {
+                feature = {
+                  chr: chr,
+                  startLeft: Math.min(endLeftNuc, endRightNuc),
+                  startRight: Math.max(endLeftNuc, endRightNuc),
+                  endLeft: Math.min(startLeftNuc, startRightNuc),
+                  endRight: Math.max(startLeftNuc, startRightNuc),
+                  color: color,
+                  score: colorIdx
+                };
+              }
+
+              feature.start = feature.startLeft;
+              feature.end = feature.endRight;
+
+              if (descriptors.length > colorIdx) {
+                feature.description = descriptors[colorIdx];
+              }
+
+              features.push(feature);
+            }
+          }
+
+          return features;
+        }
+      }
+
+    }
+
+    /*
+     * The MIT License (MIT)
+     *
+     * Copyright (c) 2014 Broad Institute
+     *
+     * Permission is hereby granted, free of charge, to any person obtaining a copy
+     * of this software and associated documentation files (the "Software"), to deal
+     * in the Software without restriction, including without limitation the rights
+     * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+     * copies of the Software, and to permit persons to whom the Software is
+     * furnished to do so, subject to the following conditions:
+     *
+     * The above copyright notice and this permission notice shall be included in
+     * all copies or substantial portions of the Software.
+     *
+     *
+     * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+     * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+     * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+     * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+     * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+     * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+     * THE SOFTWARE.
+     */
+
+    class IdeogramTrack {
+      constructor(browser) {
+        this.browser = browser;
+        this.type = 'ideogram';
+        this.id = this.type;
+        this.height = 16;
+        this.order = Number.MIN_SAFE_INTEGER;
+        this.disableButtons = true;
+        this.ignoreTrackMenu = true;
+      }
+
+      async getFeatures(chr, start, end) {
+        return [];
+      }
+
+      computePixelHeight(ignore) {
+        return this.height;
+      }
+
+      draw({
+        context,
+        referenceFrame,
+        pixelWidth,
+        pixelHeight
+      }) {
+        const chr = referenceFrame.chr;
+        const chromosome = referenceFrame.genome.getChromosome(chr);
+
+        if (undefined === chromosome || pixelWidth <= 0 || pixelHeight <= 0 || 'all' === chr.toLowerCase()) {
+          return;
+        }
+
+        const stainColors = [];
+        drawIdeogram({
+          ctx: context,
+          chr,
+          referenceFrame,
+          genome: referenceFrame.genome,
+          width: pixelWidth,
+          height: pixelHeight,
+          stainColors
+        });
+        const widthBP = Math.round(referenceFrame.bpPerPixel * pixelWidth);
+        const xBP = referenceFrame.start; // Total chromosome length can be > chromosome.bpLength for partial fastas.
+
+        let chrLength = chromosome.bpLength;
+        const cytobands = referenceFrame.genome.getCytobands(chr);
+
+        if (cytobands && cytobands.length > 0) {
+          chrLength = Math.max(chrLength, cytobands[cytobands.length - 1].end);
+        }
+
+        if (widthBP < chrLength) {
+          const percentWidth = widthBP / chrLength;
+          const percentX = xBP / chrLength;
+          let x = Math.floor(percentX * pixelWidth);
+          let ww = Math.floor(percentWidth * pixelWidth);
+          x = Math.max(0, x);
+          x = Math.min(pixelWidth - ww, x); // Push current context
+
+          context.save(); // Draw red box
+
+          context.strokeStyle = "red";
+          context.lineWidth = ww < 2 ? 1 : 2;
+          const xx = x + context.lineWidth / 2;
+          ww = ww < 2 ? 1 : ww - context.lineWidth;
+          const yy = context.lineWidth / 2;
+          const hh = pixelHeight - context.lineWidth;
+          context.strokeRect(xx, yy, ww, hh); // Pop current context
+
+          context.restore();
+        }
+      }
+
+      dispose() {
+        this.trackView = undefined;
+      }
+
+    }
+
+    function drawIdeogram({
+      ctx,
+      chr,
+      referenceFrame,
+      genome,
+      width,
+      height,
+      stainColors
+    }) {
+      const shim = 1;
+      const shim2 = 0.5 * shim;
+      const ideogramTop = 0;
+
+      if (undefined === genome) {
+        return;
+      }
+
+      IGVGraphics.fillRect(ctx, 0, 0, width, height, {
+        fillStyle: IGVColor.greyScale(255)
+      });
+      const cytobands = genome.getCytobands(chr);
+
+      if (cytobands) {
+        const center = ideogramTop + height / 2;
+        const xC = [];
+        const yC = [];
+
+        if (0 === cytobands.length) {
+          return;
+        } // Get chrLength from the cytobands -- chromsome.bpLength might not work for igv-reports fasta files, which
+        // contain only a portion of the chromosome sequence
+        // *DOESNT WORK* const chrLength = referenceFrame.genome.getChromosome(chr).bpLength;
+
+
+        const chrLength = cytobands[cytobands.length - 1].end;
+        const scale = width / chrLength; // round rect clipping path
+
+        ctx.beginPath();
+        IGVGraphics.roundRect(ctx, shim2, shim2 + ideogramTop, width - 2 * shim2, height - 2 * shim2, (height - 2 * shim2) / 2, 0, 1);
+        ctx.clip();
+
+        for (let i = 0; i < cytobands.length; i++) {
+          const cytoband = cytobands[i];
+          const start = scale * cytoband.start;
+          const end = scale * cytoband.end;
+
+          if (cytoband.type === 'c') {
+            if (cytoband.name.charAt(0) === 'p') {
+              xC[0] = start;
+              yC[0] = height + ideogramTop;
+              xC[1] = start;
+              yC[1] = ideogramTop;
+              xC[2] = end;
+              yC[2] = center;
+            } else {
+              xC[0] = end;
+              yC[0] = height + ideogramTop;
+              xC[1] = end;
+              yC[1] = ideogramTop;
+              xC[2] = start;
+              yC[2] = center;
+            }
+
+            ctx.fillStyle = "rgb(150, 0, 0)";
+            ctx.strokeStyle = "rgb(150, 0, 0)";
+            IGVGraphics.polygon(ctx, xC, yC, 1, 0);
+          } else {
+            ctx.fillStyle = getCytobandColor(stainColors, cytoband);
+            IGVGraphics.fillRect(ctx, start, shim + ideogramTop, end - start, height - 2 * shim);
+          }
+        }
+      } // round rect border
+
+
+      ctx.strokeStyle = IGVColor.greyScale(41);
+      IGVGraphics.roundRect(ctx, shim2, shim2 + ideogramTop, width - 2 * shim2, height - 2 * shim2, (height - 2 * shim2) / 2, 0, 1);
+    }
+
+    function getCytobandColor(colors, data) {
+      if (data.type === 'c') {
+        // centermere: "acen"
+        return "rgb(150, 10, 10)";
+      } else {
+        var stain = data.stain; // + 4;
+
+        var shade = 230;
+
+        if (data.type === 'p') {
+          shade = Math.floor(230 - stain / 100.0 * 230);
+        }
+
+        var c = colors[shade];
+
+        if (!c) {
+          c = "rgb(" + shade + "," + shade + "," + shade + ")";
+          colors[shade] = c;
+        }
+
+        return c;
+      }
+    }
+
+    const tracks = {
+      'ideogram': (config, browser) => {
+        return new IdeogramTrack(config, browser);
+      },
+      'sequence': (config, browser) => {
+        return new SequenceTrack(config, browser);
+      },
+      'feature': (config, browser) => {
+        return new FeatureTrack(config, browser);
+      },
+      'seg': (config, browser) => {
+        return new SegTrack(config, browser);
+      },
+      'mut': (config, browser) => {
+        return new SegTrack(config, browser);
+      },
+      'maf': (config, browser) => {
+        return new SegTrack(config, browser);
+      },
+      'wig': (config, browser) => {
+        return new WigTrack(config, browser);
+      },
+      'merged': (config, browser) => {
+        return new MergedTrack(config, browser);
+      },
+      'alignment': (config, browser) => {
+        return new BAMTrack(config, browser);
+      },
+      'interaction': (config, browser) => {
+        return new InteractionTrack(config, browser);
+      },
+      'interact': (config, browser) => {
+        return new InteractionTrack(config, browser);
+      },
+      'variant': (config, browser) => {
+        return new VariantTrack(config, browser);
+      },
+      'eqtl': (config, browser) => {
+        return new EqtlTrack(config, browser);
+      },
+      'gwas': (config, browser) => {
+        return new GWASTrack(config, browser);
+      },
+      'arc': (config, browser) => {
+        return new RnaStructTrack(config, browser);
+      },
+      'gcnv': (config, browser) => {
+        return new GCNVTrack(config, browser);
+      }
+    };
+
+    const addTrack = function (name, track) {
+      this.tracks[name] = track;
+    };
+
+    const getTrack = function (name) {
+      return this.tracks[name];
+    };
+
+    var TrackFactory = {
+      tracks,
+      addTrack,
+      getTrack
+    };
+
+    /*
+     * The MIT License (MIT)
+     *
+     * Copyright (c) 2016-2017 The Regents of the University of California
+     * Author: Jim Robinson
+     *
+     * Permission is hereby granted, free of charge, to any person obtaining a copy
+     * of this software and associated documentation files (the "Software"), to deal
+     * in the Software without restriction, including without limitation the rights
+     * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+     * copies of the Software, and to permit persons to whom the Software is
+     * furnished to do so, subject to the following conditions:
+     *
+     * The above copyright notice and this permission notice shall be included in
+     * all copies or substantial portions of the Software.
+     *
+     *
+     * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+     * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+     * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+     * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+     * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+     * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+     * THE SOFTWARE.
+     */
+    var defaultHighlightColor = "rgba(68, 134, 247, 0.25)";
+
+    class ROI {
+      constructor(config, genome) {
+        this.config = config;
+        this.name = config.name;
+        this.roiSource = FeatureSource(config, genome);
+        this.color = config.color || defaultHighlightColor;
+      }
+
+      async getFeatures(chr, start, end) {
+        return this.roiSource.getFeatures({
+          chr,
+          start,
+          end
+        });
+      }
+
+      draw(drawConfiguration) {
+        var endBP, region, coord, regions;
+        regions = drawConfiguration.features;
+
+        if (!regions) {
+          return;
+        }
+
+        endBP = drawConfiguration.bpStart + (drawConfiguration.pixelWidth * drawConfiguration.bpPerPixel + 1);
+
+        for (var i = 0, len = regions.length; i < len; i++) {
+          region = regions[i];
+
+          if (region.end < drawConfiguration.bpStart) {
+            continue;
+          }
+
+          if (region.start > endBP) {
+            break;
+          }
+
+          coord = coordinates(region, drawConfiguration.bpStart, drawConfiguration.bpPerPixel);
+          IGVGraphics.fillRect(drawConfiguration.context, coord.x, drawConfiguration.pixelTop, coord.width, drawConfiguration.pixelHeight, {
+            fillStyle: this.color
+          });
+        }
+      }
+
+    }
+
+    function coordinates(region, startBP, bpp) {
+      var ss, ee, width;
+      ss = Math.round((region.start - startBP) / bpp);
+      ee = Math.round((region.end - startBP) / bpp);
+      width = ee - ss;
+
+      if (width < 3) {
+        width = 3;
+        ss -= 1;
+      }
+
+      return {
+        x: ss,
+        width: width
+      };
+    }
+
+    /*
+     * The MIT License (MIT)
+     *
+     * Copyright (c) 2014 Broad Institute
+     *
+     * Permission is hereby granted, free of charge, to any person obtaining a copy
+     * of this software and associated documentation files (the "Software"), to deal
+     * in the Software without restriction, including without limitation the rights
+     * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+     * copies of the Software, and to permit persons to whom the Software is
+     * furnished to do so, subject to the following conditions:
+     *
+     * The above copyright notice and this permission notice shall be included in
+     * all copies or substantial portions of the Software.
+     *
+     *
+     * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+     * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+     * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+     * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+     * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+     * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+     * THE SOFTWARE.
+     */
+    class GtexSelection {
+      constructor(gene, snp) {
+        this.geneColors = {};
+        this.gene = null;
+        this.snp = null;
+        this.genesCount = 0;
+
+        if (gene) {
+          this.gene = gene.toUpperCase();
+          this.geneColors[this.gene] = brewer[this.genesCount++];
+        }
+
+        if (snp) {
+          this.snp = snp.toUpperCase();
+        }
+      }
+
+      addGene(geneName) {
+        if (!this.geneColors[geneName.toUpperCase()]) {
+          this.geneColors[geneName.toUpperCase()] = brewer[this.genesCount++];
+        }
+      }
+
+      colorForGene(geneName) {
+        return this.geneColors[geneName.toUpperCase()];
+      }
+
+    }
+
+    var brewer = new Array(); // Set +!
+
+    brewer.push("rgb(228,26,28)");
+    brewer.push("rgb(55,126,184)");
+    brewer.push("rgb(77,175,74)");
+    brewer.push("rgb(166,86,40)");
+    brewer.push("rgb(152,78,163)");
+    brewer.push("rgb(255,127,0)");
+    brewer.push("rgb(247,129,191)");
+    brewer.push("rgb(153,153,153)");
+    brewer.push("rgb(255,255,51)"); // #Set 2
+
+    brewer.push("rgb(102, 194, 165");
+    brewer.push("rgb(252, 141, 98");
+    brewer.push("rgb(141, 160, 203");
+    brewer.push("rgb(231, 138, 195");
+    brewer.push("rgb(166, 216, 84");
+    brewer.push("rgb(255, 217, 47");
+    brewer.push("rgb(229, 196, 148");
+    brewer.push("rgb(179, 179, 179"); //#Set 3
+
+    brewer.push("rgb( 141, 211, 199");
+    brewer.push("rgb(255, 255, 179");
+    brewer.push("rgb(190, 186, 218");
+    brewer.push("rgb(251, 128, 114");
+    brewer.push("rgb(128, 177, 211");
+    brewer.push("rgb(253, 180, 98");
+    brewer.push("rgb(179, 222, 105");
+    brewer.push("rgb(252, 205, 229");
+    brewer.push("rgb(217, 217, 217");
+    brewer.push("rgb(188, 128, 189");
+    brewer.push("rgb(204, 235, 197");
+    brewer.push("rgb(255, 237, 111");
+
+    /*
+     * The MIT License (MIT)
+     *
+     * Copyright (c) 2016-2017 The Regents of the University of California
+     * Author: Jim Robinson
+     *
+     * Permission is hereby granted, free of charge, to any person obtaining a copy
+     * of this software and associated documentation files (the "Software"), to deal
+     * in the Software without restriction, including without limitation the rights
+     * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+     * copies of the Software, and to permit persons to whom the Software is
+     * furnished to do so, subject to the following conditions:
+     *
+     * The above copyright notice and this permission notice shall be included in
+     * all copies or substantial portions of the Software.
+     *
+     *
+     * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+     * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+     * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+     * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+     * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+     * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+     * THE SOFTWARE.
+     */
+
+    /**
+     * Minimal support for the legacy IGV desktop session format.
+     */
+    class XMLSession {
+      constructor(xmlString, knownGenomes) {
+        const parser = new DOMParser();
+        const xmlDoc = parser.parseFromString(xmlString, "text/xml");
+        this.processRootNode(xmlDoc, knownGenomes);
+        const resourceElements = xmlDoc.getElementsByTagName("Resource");
+        const trackElements = xmlDoc.getElementsByTagName("Track");
+        const hasTrackElements = trackElements && trackElements.length > 0;
+        const tracks = [];
+        this.tracks = tracks;
+        const resourceMap = new Map();
+        Array.from(resourceElements).forEach(function (r, idx) {
+          var config = {
+            url: r.getAttribute("path"),
+            indexURL: r.getAttribute("index"),
+            order: idx
+          };
+          resourceMap.set(config.url, config);
+
+          if (!hasTrackElements) {
+            tracks.push(config);
+          }
+        }); // Check for optional Track section
+
+        if (hasTrackElements) {
+          Array.from(trackElements).forEach(function (track) {
+            const subtracks = track.getElementsByTagName("Track");
+
+            if (subtracks && subtracks.length > 0) {
+              const mergedTrack = {
+                type: 'merged',
+                tracks: []
+              };
+              extractTrackAttributes(track, mergedTrack);
+              tracks.push(mergedTrack);
+              Array.from(subtracks).forEach(function (t) {
+                t.processed = true;
+                const id = t.getAttribute("id");
+                const config = resourceMap.get(id);
+
+                if (config) {
+                  mergedTrack.tracks.push(config);
+                  extractTrackAttributes(t, config);
+                  config.autoscale = false;
+                  mergedTrack.height = config.height; // Add alpha for merged track colors.  Alpha is not recorded by IGV desktop in XML session
+                  //const color = t.getAttribute("color");
+                  //if (color) {
+                  //    config.color = "rgba(" + color + ",0.5)";
+                  //}
+                }
+              });
+            } else if (!track.processed) {
+              const id = track.getAttribute("id");
+              const res = resourceMap.get(id);
+
+              if (res) {
+                tracks.push(res);
+                extractTrackAttributes(track, res);
+              }
+            }
+          });
+        }
+      }
+
+      processRootNode(xmlDoc, knownGenomes) {
+        const elements = xmlDoc.getElementsByTagName("Session");
+
+        if (!elements || elements.length === 0) ;
+
+        const session = elements.item(0);
+        const genome = session.getAttribute("genome");
+        const locus = session.getAttribute("locus");
+        const ucscID = session.getAttribute("ucscID");
+
+        if (knownGenomes && knownGenomes.hasOwnProperty(genome)) {
+          this.genome = genome;
+        } else {
+          this.reference = {
+            fastaURL: genome
+          };
+
+          if (ucscID) {
+            this.reference.id = ucscID;
+          }
+        }
+
+        if (locus) {
+          this.locus = locus;
+        }
+      }
+
+    }
+
+    function extractTrackAttributes(track, config) {
+      config.name = track.getAttribute("name");
+      const color = track.getAttribute("color");
+
+      if (color) {
+        config.color = "rgb(" + color + ")";
+      }
+
+      const altColor = track.getAttribute("altColor");
+
+      if (color) {
+        config.altColor = "rgb(" + altColor + ")";
+      }
+
+      const height = track.getAttribute("height");
+
+      if (height) {
+        config.height = parseInt(height);
+      }
+
+      const autoScale = track.getAttribute("autoScale");
+
+      if (autoScale) {
+        config.autoscale = autoScale === "true";
+      }
+
+      const autoscaleGroup = track.getAttribute("autoscaleGroup");
+
+      if (autoscaleGroup) {
+        config.autoscaleGroup = autoscaleGroup;
+      }
+
+      const windowFunction = track.getAttribute("windowFunction");
+
+      if (windowFunction) {
+        config.windowFunction = windowFunction;
+      }
+
+      const visWindow = track.getAttribute("visibilityWindow") || track.getAttribute("featureVisibilityWindow");
+
+      if (visWindow) {
+        config.visibilityWindow = visWindow;
+      }
+
+      const indexed = track.getAttribute("indexed");
+
+      if (indexed) {
+        config.indexed = indexed === "true";
+      }
+
+      const normalize = track.getAttribute("normalize");
+
+      if (normalize) {
+        config.normalize = normalize === "true";
+      }
+
+      const dataRangeCltn = track.getElementsByTagName("DataRange");
+
+      if (dataRangeCltn.length > 0) {
+        const dataRange = dataRangeCltn.item(0);
+        config.min = Number.parseFloat(dataRange.getAttribute("minimum"));
+        config.max = Number.parseFloat(dataRange.getAttribute("maximum"));
+        config.logScale = dataRange.getAttribute("type") === "LOG";
+      }
+    }
+
+    /*
+     * The MIT License (MIT)
+     *
+     * Copyright (c) 2014-2015 Broad Institute
+     *
+     * Permission is hereby granted, free of charge, to any person obtaining a copy
+     * of this software and associated documentation files (the "Software"), to deal
+     * in the Software without restriction, including without limitation the rights
+     * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+     * copies of the Software, and to permit persons to whom the Software is
+     * furnished to do so, subject to the following conditions:
+     *
+     * The above copyright notice and this permission notice shall be included in
+     * all copies or substantial portions of the Software.
+     *
+     *
+     * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+     * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+     * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+     * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+     * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+     * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+     * THE SOFTWARE.
+     */
+    const splitLines = splitLines$3;
+
+    class SampleInformation {
+      constructor() {
+        this.attributes = {};
+        this.plinkLoaded = false;
+      }
+
+      async loadPlinkFile(url, config) {
+        if (!config) config = {};
+        var options = buildOptions(config); // Add oauth token, if any
+
+        const data = await igvxhr.loadString(url, options);
+        var lines = splitLines(data);
+
+        for (let line of lines) {
+          var line_arr = line.split(' ');
+          this.attributes[line_arr[1]] = {
+            familyId: line_arr[0],
+            fatherId: line_arr[2],
+            motherId: line_arr[3],
+            sex: line_arr[4],
+            phenotype: line_arr[5]
+          };
+        }
+
+        this.plinkLoaded = true;
+        return this;
+      }
+      /**
+       * Return the attributes for the given sample as a map-like object (key-value pairs)
+       * @param sample
+       */
+
+
+      getAttributes(sample) {
+        return this.attributes[sample];
+      }
+
+      getAttributeNames() {
+        if (this.hasAttributes()) {
+          return Object.keys(this.attributes[Object.keys(this.attributes)[0]]);
+        } else return [];
+      }
+
+      hasAttributes() {
+        return Object.keys(this.attributes).length > 0;
+      }
+
+    }
+
+    function loadPlinkFile(url, config) {
+      const si = new SampleInformation();
+      return si.loadPlinkFile(url, config);
+    }
+
+    /*
+     * The MIT License (MIT)
+     *
+     * Copyright (c) 2014 Broad Institute
+     *
+     * Permission is hereby granted, free of charge, to any person obtaining a copy
+     * of this software and associated documentation files (the "Software"), to deal
+     * in the Software without restriction, including without limitation the rights
+     * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+     * copies of the Software, and to permit persons to whom the Software is
+     * furnished to do so, subject to the following conditions:
+     *
+     * The above copyright notice and this permission notice shall be included in
+     * all copies or substantial portions of the Software.
+     *
+     *
+     * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+     * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+     * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+     * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+     * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+     * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+     * THE SOFTWARE.
+     */
+
+    class ReferenceFrame {
+      constructor(genome, chr, start, end, bpPerPixel) {
+        this.genome = genome;
+        this.chr = chr;
+        this.start = start;
+        this.initialEnd = end; // TODO WARNING THIS IS NOT UPDATED !!!
+
+        this.initialStart = start;
+        this.bpPerPixel = bpPerPixel;
+        this.id = guid();
+      }
+
+      calculateEnd(pixels) {
+        return this.start + this.bpPerPixel * pixels;
+      }
+
+      calculateBPP(end, pixels) {
+        return (end - this.start) / pixels;
+      }
+
+      set(json) {
+        this.chr = json.chr;
+        this.start = json.start;
+        this.bpPerPixel = json.bpPerPixel;
+      }
+
+      toPixels(bp) {
+        return bp / this.bpPerPixel;
+      }
+
+      toBP(pixels) {
+        return this.bpPerPixel * pixels;
+      }
+      /**
+       * Shift frame by stated pixels.  Return true if view changed, false if not.
+       * @param pixels
+       * @param viewportWidth
+       */
+
+
+      shiftPixels(pixels, viewportWidth) {
+        const start = this.start;
+        this.start += pixels * this.bpPerPixel;
+        this.clamp(viewportWidth);
+        return start !== this.start;
+      }
+
+      clamp(viewportWidth) {
+        // clamp left
+        const min = this.genome.getChromosome(this.chr).bpStart || 0;
+        this.start = Math.max(min, this.start); // clamp right
+
+        if (viewportWidth) {
+          var chromosome = this.genome.getChromosome(this.chr);
+          var maxEnd = chromosome.bpLength;
+          var maxStart = maxEnd - viewportWidth * this.bpPerPixel;
+
+          if (this.start > maxStart) {
+            this.start = maxStart;
+          }
+        }
+      }
+
+      getChromosome() {
+        return this.genome.getChromosome(this.chr);
+      }
+
+      presentLocus(pixels) {
+        if ('all' === this.chr) {
+          return this.chr;
+        } else {
+          const ss = numberFormatter$1(Math.floor(this.start) + 1);
+          const ee = numberFormatter$1(Math.round(this.start + this.bpPerPixel * pixels));
+          return `${this.chr}:${ss}-${ee}`;
+        }
+      }
+
+    }
+
+    function createReferenceFrameList(browser, loci) {
+      const viewportWidth = browser.computeViewportWidth(loci.length, browser.getViewportContainerWidth());
+      return loci.map(locusObject => {
+        // If a flanking region is defined, and the search object is a symbol ("gene") type, adjust start and end
+        if (browser.flanking && locusObject.gene) {
+          locusObject.start = Math.max(0, locusObject.start - browser.flanking);
+          locusObject.end += browser.flanking;
+        } // Validate the range.  This potentionally modifies start & end of locusObject.
+
+
+        const chromosome = browser.genome.getChromosome(locusObject.chr);
+        validateLocusExtent(chromosome.bpLength, locusObject, browser.minimumBases());
+        const referenceFrame = new ReferenceFrame(browser.genome, locusObject.chr, locusObject.start, locusObject.end, (locusObject.end - locusObject.start) / viewportWidth);
+        referenceFrame.locusSearchString = locusObject.locusSearchString; // GTEX hack
+
+        if (locusObject.gene || locusObject.snp) {
+          referenceFrame.selection = new GtexSelection(locusObject.gene, locusObject.snp);
+        }
+
+        return referenceFrame;
+      });
+    }
+
+    function adjustReferenceFrame(referenceFrame, viewportWidth, alignmentStart, alignmentLength) {
+      const alignmentEE = alignmentStart + alignmentLength;
+      const alignmentCC = (alignmentStart + alignmentEE) / 2;
+      referenceFrame.start = alignmentCC - referenceFrame.bpPerPixel * (viewportWidth / 2);
+      referenceFrame.initialEnd = referenceFrame.start + referenceFrame.bpPerPixel * viewportWidth;
+      referenceFrame.locusSearchString = referenceFrame.presentLocus(viewportWidth);
+    }
+
+    function createReferenceFrameWithAlignment(genome, chromosomeName, bpp, viewportWidth, alignmentStart, alignmentLength) {
+      const alignmentEE = alignmentStart + alignmentLength;
+      const alignmentCC = (alignmentStart + alignmentEE) / 2;
+      const ss = alignmentCC - bpp * (viewportWidth / 2);
+      const ee = ss + bpp * viewportWidth;
+      const referenceFrame = new ReferenceFrame(genome, chromosomeName, ss, ee, bpp);
+      referenceFrame.locusSearchString = referenceFrame.presentLocus(viewportWidth);
+      return referenceFrame;
+    }
+
+    const defaultNucleotideColors = {
+      "A": "rgb(  0, 200,   0)",
+      "C": "rgb(  0,0,200)",
+      "T": "rgb(255,0,0)",
+      "G": "rgb(209,113,  5)",
+      "N": "rgb(80,80,80)"
+    };
+
+    const DEFAULT_SEARCH_CONFIG = {
+      timeout: 5000,
+      type: "plain",
+      // Legacy plain text support -- deprecated
+      url: 'https://igv.org/genomes/locus.php?genome=$GENOME$&name=$FEATURE$',
+      coords: 0,
+      chromosomeField: "chromosome",
+      startField: "start",
+      endField: "end",
+      geneField: "gene",
+      snpField: "snp"
+    };
+
+    async function search(browser, string) {
+      if (undefined === string || '' === string.trim()) {
+        return;
+      }
+
+      if (string && string.trim().toLowerCase() === "all" || string === "*") {
+        string = "all";
+      }
+
+      const loci = string.split(' ');
+      let searchConfig = browser.searchConfig || DEFAULT_SEARCH_CONFIG;
+      let list = [];
+
+      const searchLocus = async locus => {
+        let locusObject = parseLocusString(browser, locus);
+
+        if (!locusObject) {
+          locusObject = browser.genome.featureDB[locus.toUpperCase()];
+        }
+
+        if (!locusObject && browser.config && false !== browser.config.search) {
+          try {
+            locusObject = await searchWebService(browser, locus, searchConfig);
+          } catch (error) {
+            console.error(error);
+            throw Error("Search service currently unavailable.");
+          }
+        }
+
+        return locusObject;
+      };
+
+      for (let locus of loci) {
+        const locusObject = await searchLocus(locus);
+
+        if (locusObject) {
+          locusObject.locusSearchString = locus;
+          list.push(locusObject);
+        }
+      } // If nothing is found, consider possibility that loci name itself has spaces
+
+
+      if (list.length === 0) {
+        const locusObject = await searchLocus(string);
+
+        if (locusObject) {
+          locusObject.locusSearchString = string;
+          list.push(locusObject);
+        }
+      }
+
+      return 0 === list.length ? undefined : list;
+    }
+
+    function parseLocusString(browser, locus) {
+      const a = locus.split(':');
+      const chr = a[0];
+
+      if ('all' === chr && browser.genome.getChromosome(chr)) {
+        return {
+          chr,
+          start: 0,
+          end: browser.genome.getChromosome(chr).bpLength
+        };
+      } else if (undefined === browser.genome.getChromosome(chr)) {
+        return undefined;
+      } else {
+        const queryChr = browser.genome.getChromosomeName(chr);
+        const extent = {
+          chr: queryChr,
+          start: 0,
+          end: browser.genome.getChromosome(chr).bpLength
+        };
+
+        if (a.length > 1) {
+          const b = a[1].split('-');
+
+          if (b.length > 2) {
+            return undefined;
+          } else {
+            let numeric;
+            numeric = b[0].replace(/,/g, '');
+
+            if (isNaN(numeric)) {
+              return undefined;
+            }
+
+            extent.start = parseInt(numeric, 10) - 1;
+            extent.end = extent.start + 1;
+
+            if (1 === b.length) {
+              extent.start -= 20;
+              extent.end += 20;
+            }
+
+            if (2 === b.length) {
+              numeric = b[1].replace(/,/g, '');
+
+              if (isNaN(numeric)) {
+                return undefined;
+              } else {
+                extent.end = parseInt(numeric, 10);
+              }
+            }
+          }
+        }
+
+        return extent;
+      }
+    }
+
+    async function searchWebService(browser, locus, searchConfig) {
+      let path = searchConfig.url.replace("$FEATURE$", locus.toUpperCase());
+
+      if (path.indexOf("$GENOME$") > -1) {
+        path = path.replace("$GENOME$", browser.genome.id ? browser.genome.id : "hg19");
+      }
+
+      const options = searchConfig.timeout ? {
+        timeout: searchConfig.timeout
+      } : undefined;
+      const result = await igvxhr.loadString(path, options);
+      const locusObject = processSearchResult(browser, result, searchConfig);
+
+      if (locusObject) {
+        locusObject.locusSearchString = locus;
+      }
+
+      return locusObject;
+    }
+
+    function processSearchResult(browser, result, searchConfig) {
+      let results;
+
+      if ('plain' === searchConfig.type) {
+        results = parseSearchResults(browser, result);
+      } else {
+        results = JSON.parse(result);
+      }
+
+      if (searchConfig.resultsField) {
+        results = results[searchConfig.resultsField];
+      }
+
+      if (!results || 0 === results.length) {
+        return undefined;
+      } else {
+        const chromosomeField = searchConfig.chromosomeField || "chromosome";
+        const startField = searchConfig.startField || "start";
+        const endField = searchConfig.endField || "end";
+        const coords = searchConfig.coords || 1;
+        let result;
+
+        if (Array.isArray(results)) {
+          // Ignoring all but first result for now
+          // TODO -- present all and let user select if results.length > 1
+          result = results[0];
+        } else {
+          // When processing search results from Ensembl REST API
+          // Example: https://rest.ensembl.org/lookup/symbol/macaca_fascicularis/BRCA2?content-type=application/json
+          result = results;
+        }
+
+        if (!(result.hasOwnProperty(chromosomeField) && result.hasOwnProperty(startField))) {
+          console.error("Search service results must include chromosome and start fields: " + result);
+        }
+
+        const chrResult = result[chromosomeField];
+        const chromosome = browser.genome.getChromosome(chrResult);
+
+        if (!chromosome) {
+          return undefined;
+        }
+
+        const chr = chromosome.name;
+        let start = result[startField] - coords;
+        let end = result[endField];
+
+        if (undefined === end) {
+          end = start + 1;
+        }
+
+        const locusObject = {
+          chr,
+          start,
+          end
+        }; // Some GTEX hacks
+
+        const type = result.type ? result.type : "gene";
+
+        if (searchConfig.geneField && type === "gene") {
+          locusObject.gene = result[searchConfig.geneField];
+        }
+
+        if (searchConfig.snpField && type === "snp") {
+          locusObject.snp = result[searchConfig.snpField];
+        }
+
+        return locusObject;
+      }
+    }
+    /**
+     * Parse the igv line-oriented (non json) search results.
+     * Example
+     *    EGFR    chr7:55,086,724-55,275,031    refseq
+     *
+     */
+
+
+    function parseSearchResults(browser, data) {
+      const linesTrimmed = [];
+      const results = [];
+      const lines = splitLines$3(data);
+      lines.forEach(function (item) {
+        if ("" === item) ; else {
+          linesTrimmed.push(item);
+        }
+      });
+      linesTrimmed.forEach(function (line) {
+        var tokens = line.split("\t"),
+            source,
+            locusTokens,
+            rangeTokens,
+            obj;
+
+        if (tokens.length >= 3) {
+          locusTokens = tokens[1].split(":");
+          rangeTokens = locusTokens[1].split("-");
+          source = tokens[2].trim();
+          obj = {
+            gene: tokens[0],
+            chromosome: browser.genome.getChromosomeName(locusTokens[0].trim()),
+            start: parseInt(rangeTokens[0].replace(/,/g, '')),
+            end: parseInt(rangeTokens[1].replace(/,/g, '')),
+            type: "gtex" === source ? "snp" : "gene"
+          };
+          results.push(obj);
+        }
+      });
+      return results;
+    } // Export some functions for unit testing
+
+    /*
+     * The MIT License (MIT)
+     *
+     * Copyright (c) 2014 Broad Institute
+     *
+     * Permission is hereby granted, free of charge, to any person obtaining a copy
+     * of this software and associated documentation files (the "Software"), to deal
+     * in the Software without restriction, including without limitation the rights
+     * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+     * copies of the Software, and to permit persons to whom the Software is
+     * furnished to do so, subject to the following conditions:
+     *
+     * The above copyright notice and this permission notice shall be included in
+     * all copies or substantial portions of the Software.
+     *
+     *
+     * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+     * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+     * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+     * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+     * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+     * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+     * THE SOFTWARE.
+     */
+    class NavbarManager {
+      constructor(browser) {
+        this.browser = browser;
+      }
+
+      navbarDidResize(width, isWholeGenomeView) {
+        this.updateNavbar(this.createResponsiveClassSchedule(width, isWholeGenomeView));
+      }
+
+      updateNavbar(responsiveClassSchedule) {
+        this.browser['$toggle_button_container'].removeClass();
+        this.browser['$toggle_button_container'].addClass(responsiveClassSchedule['$toggle_button_container']);
+        this.browser.zoomWidget['$zoomContainer'].removeClass();
+        this.browser.zoomWidget['$zoomContainer'].addClass(responsiveClassSchedule['$zoomContainer']);
+      }
+
+      createResponsiveClassSchedule(navbarWidth, isWholeGenomeView) {
+        let candidates = {};
+
+        if (isWholeGenomeView) {
+          this.browser.windowSizePanel.hide();
+        } else {
+          this.browser.windowSizePanel.show();
+        }
+
+        if (navbarWidth > 990) {
+          candidates['$toggle_button_container'] = 'igv-navbar-toggle-button-container';
+          candidates['$zoomContainer'] = 'igv-zoom-widget';
+        } else if (navbarWidth > 860) {
+          candidates['$toggle_button_container'] = 'igv-navbar-toggle-button-container';
+          candidates['$zoomContainer'] = 'igv-zoom-widget-900';
+        } else if (navbarWidth > 540) {
+          candidates['$toggle_button_container'] = 'igv-navbar-toggle-button-container-750';
+          candidates['$zoomContainer'] = 'igv-zoom-widget-900';
+        } else {
+          candidates['$toggle_button_container'] = 'igv-navbar-toggle-button-container-750';
+          candidates['$zoomContainer'] = 'igv-zoom-widget-900';
+          this.browser.windowSizePanel.hide();
+        }
+
+        if (isWholeGenomeView) {
+          candidates['$zoomContainer'] = 'igv-zoom-widget-hidden';
+        }
+
+        return candidates;
+      }
+
+    }
+
+    /*
+     * The MIT License (MIT)
+     *
+     * Copyright (c) 2016-2017 The Regents of the University of California
+     * Author: Jim Robinson
+     *
+     * Permission is hereby granted, free of charge, to any person obtaining a copy
+     * of this software and associated documentation files (the "Software"), to deal
+     * in the Software without restriction, including without limitation the rights
+     * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+     * copies of the Software, and to permit persons to whom the Software is
+     * furnished to do so, subject to the following conditions:
+     *
+     * The above copyright notice and this permission notice shall be included in
+     * all copies or substantial portions of the Software.
+     *
+     *
+     * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+     * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+     * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+     * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+     * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+     * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+     * THE SOFTWARE.
+     */
+
+    const ChromosomeSelectWidget = function (browser, $parent) {
+      this.showAllChromosomes = browser.config.showAllChromosomes !== false; // i.e. default to true
+
+      this.$container = $('<div>', {
+        class: 'igv-chromosome-select-widget-container'
+      });
+      $parent.append(this.$container);
+      this.$select = $('<select>', {
+        'name': 'chromosome-select-widget'
+      });
+      this.$container.append(this.$select);
+      this.$select.on('change', function () {
+        const value = $(this).val();
+
+        if (value !== '') {
+          browser.search($(this).val());
+          $(this).blur();
+        }
+      });
+    };
+
+    ChromosomeSelectWidget.prototype.update = function (genome) {
+      this.$select.empty();
+      const list = this.showAllChromosomes ? genome.chromosomeNames.slice() : genome.wgChromosomeNames.slice(); // slice used to copy list
+
+      if (genome.showWholeGenomeView()) {
+        list.unshift('all');
+        list.unshift('');
+      }
+
+      for (let name of list) {
+        var $o;
+        $o = $('<option>', {
+          'value': name
+        });
+        this.$select.append($o);
+        $o.text(name);
+      }
+    };
+
+    /*
+     * The MIT License (MIT)
+     *
+     * Copyright (c) 2014 Broad Institute
+     *
+     * Permission is hereby granted, free of charge, to any person obtaining a copy
+     * of this software and associated documentation files (the "Software"), to deal
+     * in the Software without restriction, including without limitation the rights
+     * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+     * copies of the Software, and to permit persons to whom the Software is
+     * furnished to do so, subject to the following conditions:
+     *
+     * The above copyright notice and this permission notice shall be included in
+     * all copies or substantial portions of the Software.
+     *
+     *
+     * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+     * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+     * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+     * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+     * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+     * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+     * THE SOFTWARE.
+     */
+
+    class WindowSizePanel {
+      constructor($parent, browser) {
+        this.$container = $('<div>', {
+          class: 'igv-windowsize-panel-container'
+        });
+        $parent.append(this.$container);
+        this.browser = browser;
+      }
+
+      show() {
+        this.$container.show();
+      }
+
+      hide() {
+        this.$container.hide();
+      }
+
+      updatePanel(referenceFrameList) {
+        this.$container.text(1 === referenceFrameList.length ? prettyBasePairNumber(Math.round(this.browser.getViewportWidth() * referenceFrameList[0].bpPerPixel)) : '');
+      }
+
+    }
+
+    function prettyBasePairNumber(raw) {
+      var denom, units, value, floored;
+
+      if (raw > 1e7) {
+        denom = 1e6;
+        units = " mb";
+      } else if (raw > 1e4) {
+        denom = 1e3;
+        units = " kb";
+        value = raw / denom;
+        floored = Math.floor(value);
+        return numberFormatter$1(floored) + units;
+      } else {
+        return numberFormatter$1(raw) + " bp";
+      }
+
+      value = raw / denom;
+      floored = Math.floor(value);
+      return floored.toString() + units;
+    }
+
+    /*
+     * The MIT License (MIT)
+     *
+     * Copyright (c) 2016 University of California San Diego
+     * Author: Jim Robinson
+     *
+     * Permission is hereby granted, free of charge, to any person obtaining a copy
+     * of this software and associated documentation files (the "Software"), to deal
+     * in the Software without restriction, including without limitation the rights
+     * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+     * copies of the Software, and to permit persons to whom the Software is
+     * furnished to do so, subject to the following conditions:
+     *
+     * The above copyright notice and this permission notice shall be included in
+     * all copies or substantial portions of the Software.
+     *
+     *
+     * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+     * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+     * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+     * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+     * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+     * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+     * THE SOFTWARE.
+     */
+
+    const CursorGuide = function ($cursorGuideParent, $controlParent, config, browser) {
+      const self = this;
+      this.browser = browser;
+      this.$horizontalGuide = $('<div class="igv-cursor-guide-horizontal">');
+      $cursorGuideParent.append(this.$horizontalGuide);
+      this.$verticalGuide = $('<div class="igv-cursor-guide-vertical">');
+      $cursorGuideParent.append(this.$verticalGuide); // Guide line is bound within track area, and offset by 5 pixels so as not to interfere mouse clicks.
+
+      $cursorGuideParent.on('mousemove.cursor-guide', e => {
+        e.preventDefault();
+        const $target = $(document.elementFromPoint(e.clientX, e.clientY));
+        const $parent = $target.parent();
+        let $viewport = undefined;
+
+        if ($parent.hasClass('igv-viewport-content')) {
+          $viewport = $parent.parent();
+        } else if ($parent.hasClass('igv-viewport') && $target.hasClass('igv-viewport-content')) {
+          $viewport = $parent;
+        } else if ($parent.hasClass('igv-viewport-container') && $target.hasClass('igv-viewport')) {
+          $viewport = $target;
+        }
+
+        if ($viewport) {
+          const result = mouseHandler(e, $viewport, this.$horizontalGuide, this.$verticalGuide, $cursorGuideParent, browser);
+
+          if (result) {
+            const {
+              bp,
+              start,
+              end,
+              interpolant
+            } = result;
+
+            if (this.customMouseHandler) {
+              this.customMouseHandler({
+                bp,
+                start,
+                end,
+                interpolant
+              });
+            }
+          }
+        }
+      });
+
+      if (true === config.showCursorTrackingGuideButton) {
+        this.$button = $('<div class="igv-navbar-button">');
+        $controlParent.append(this.$button);
+        this.$button.text('cursor guide');
+        this.$button.on('click', function () {
+          if (true === browser.cursorGuideVisible) {
+            self.doHide();
+          } else {
+            self.doShow();
+          }
+        });
+      }
+    };
+
+    function mouseHandler(event, $viewport, $horizontalGuide, $verticalGuide, $cursorGuideParent, browser) {
+      const {
+        x: xParent,
+        y: yParent
+      } = translateMouseCoordinates$1(event, $cursorGuideParent.get(0));
+      const top = `${yParent}px`;
+      $horizontalGuide.css({
+        top
+      });
+      const left = `${xParent}px`;
+      $verticalGuide.css({
+        left
+      });
+      const {
+        x,
+        xNormalized,
+        width
+      } = translateMouseCoordinates$1(event, $viewport.get(0));
+      const viewport = browser.getViewportWithGUID($viewport.data('viewportGUID'));
+
+      if (undefined === viewport) {
+        // console.log('ERROR: No viewport found');
+        return undefined;
+      }
+
+      const {
+        start,
+        bpPerPixel
+      } = viewport.referenceFrame;
+      const end = 1 + start + width * bpPerPixel;
+      const bp = 1 + Math.floor(start + x * bpPerPixel); // console.log(`bp ${ StringUtils.numberFormatter(bp) }`)
+
+      if (browser.rulerTrack) {
+        const index = browser.referenceFrameList.indexOf(viewport.referenceFrame);
+        const rulerViewport = browser.rulerTrack.trackView.viewports[index];
+        rulerViewport.mouseMove(event);
+      }
+
+      const $host = $viewport.closest('.igv-track-container');
+      return {
+        bp,
+        start,
+        end,
+        interpolant: xNormalized,
+        host_css_left: left,
+        $host
+      };
+    }
+
+    CursorGuide.prototype.doHide = function () {
+      if (this.$button) {
+        this.$button.removeClass('igv-navbar-button-clicked');
+      }
+
+      this.browser.hideCursorGuide();
+
+      if (this.browser.rulerTrack) {
+        for (let viewport of this.browser.rulerTrack.trackView.viewports) {
+          viewport.$tooltip.hide();
+        }
+      }
+    };
+
+    CursorGuide.prototype.doShow = function () {
+      this.$button.addClass('igv-navbar-button-clicked');
+      this.browser.showCursorGuide();
+    };
+
+    CursorGuide.prototype.setState = function (cursorGuideVisible) {
+      if (this.$button) {
+        if (true === cursorGuideVisible) {
+          this.$button.addClass('igv-navbar-button-clicked');
+        } else {
+          this.$button.removeClass('igv-navbar-button-clicked');
+        }
+      }
+    };
+
+    CursorGuide.prototype.disable = function () {
+      this.doHide();
+      this.$verticalGuide.hide();
+      this.$horizontalGuide.hide();
+    };
+
+    CursorGuide.prototype.enable = function () {
+      if (this.$button) {
+        this.$button.show();
+      }
+    };
+
+    /*
+     * The MIT License (MIT)
+     *
+     * Copyright (c) 2016 University of California San Diego
+     * Author: Jim Robinson
+     *
+     * Permission is hereby granted, free of charge, to any person obtaining a copy
+     * of this software and associated documentation files (the "Software"), to deal
+     * in the Software without restriction, including without limitation the rights
+     * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+     * copies of the Software, and to permit persons to whom the Software is
+     * furnished to do so, subject to the following conditions:
+     *
+     * The above copyright notice and this permission notice shall be included in
+     * all copies or substantial portions of the Software.
+     *
+     *
+     * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+     * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+     * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+     * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+     * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+     * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+     * THE SOFTWARE.
+     */
+
+    class CenterGuide {
+      constructor($guideParent, $controlParent, config, browser) {
+        const self = this;
+        this.browser = browser;
+        this.$container = $('<div class="igv-center-guide igv-center-guide-thin">');
+        $guideParent.append(this.$container);
+
+        if (true === config.showCenterGuideButton) {
+          this.$centerGuideToggle = $('<div class="igv-navbar-button">');
+          $controlParent.append(this.$centerGuideToggle);
+          this.$centerGuideToggle.text('center line');
+          this.$centerGuideToggle.on('click', function () {
+            if (true === browser.isCenterGuideVisible) {
+              self.doHide();
+            } else {
+              self.doShow();
+            }
+          });
+        }
+      }
+
+      doHide() {
+        if (this.$centerGuideToggle) {
+          this.$centerGuideToggle.removeClass('igv-navbar-button-clicked');
+        }
+
+        this.browser.hideCenterGuide();
+      }
+
+      doShow() {
+        if (this.$centerGuideToggle) {
+          this.$centerGuideToggle.addClass('igv-navbar-button-clicked');
+        }
+
+        this.browser.showCenterGuide();
+      }
+
+      setState(isCenterGuideVisible) {
+        if (this.$centerGuideToggle) {
+          if (true === isCenterGuideVisible) {
+            this.$centerGuideToggle.addClass('igv-navbar-button-clicked');
+          } else {
+            this.$centerGuideToggle.removeClass('igv-navbar-button-clicked');
+          }
+        }
+      }
+
+      forcedHide() {
+        if (this.$centerGuideToggle) {
+          this.$centerGuideToggle.hide();
+        }
+
+        if (true === this.browser.isCenterGuideVisible) {
+          this.$container.hide();
+        }
+      }
+
+      forcedShow() {
+        if (this.$centerGuideToggle) {
+          this.$centerGuideToggle.show();
+        }
+
+        if (true === this.browser.isCenterGuideVisible) {
+          this.$container.show();
+        }
+      }
+
+      repaint() {
+        if (this.browser.referenceFrameList) {
+          const referenceFrame = this.browser.referenceFrameList[0];
+          const ppb = 1.0 / referenceFrame.bpPerPixel;
+
+          if (ppb > 1) {
+            // This is terrible hack but should be irrlevant after the coming DOM refactor
+            let trackView = this.browser.trackViews[0];
+            const axisWidth = trackView.$axis.width();
+            const viewportContainerWidth = trackView.$viewportContainer.width();
+            const viewportWidth = viewportContainerWidth - axisWidth; // This assumes 1 viewport
+
+            const xy = trackView.$viewportContainer.position();
+            const halfWidth = Math.round(viewportWidth / 2);
+            const center = xy.left + halfWidth + axisWidth;
+            const width = referenceFrame.toPixels(1);
+            const left = center - 0.5 * width;
+            const ls = Math.round(left).toString() + 'px';
+            const ws = Math.round(width).toString() + 'px';
+            this.$container.css({
+              left: ls,
+              width: ws
+            });
+            this.$container.removeClass('igv-center-guide-thin');
+            this.$container.addClass('igv-center-guide-wide');
+          } else {
+            this.$container.css({
+              left: '50%',
+              width: '1px'
+            });
+            this.$container.removeClass('igv-center-guide-wide');
+            this.$container.addClass('igv-center-guide-thin');
+          }
+        }
+      }
+
+      resize() {
+        this.repaint();
+      }
+
+    }
+
+    /*
+     * The MIT License (MIT)
+     *
+     * Copyright (c) 2016 University of California San Diego
+     * Author: Jim Robinson
+     *
+     * Permission is hereby granted, free of charge, to any person obtaining a copy
+     * of this software and associated documentation files (the "Software"), to deal
+     * in the Software without restriction, including without limitation the rights
+     * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+     * copies of the Software, and to permit persons to whom the Software is
+     * furnished to do so, subject to the following conditions:
+     *
+     * The above copyright notice and this permission notice shall be included in
+     * all copies or substantial portions of the Software.
+     *
+     *
+     * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+     * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+     * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+     * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+     * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+     * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+     * THE SOFTWARE.
+     */
+
+    const TrackLabelControl = function ($parent, browser) {
+      var self = this;
+      this.browser = browser;
+      this.$button = $('<div class="igv-navbar-button">');
+      $parent.append(this.$button);
+      this.$button.text('track labels');
+      this.$button.on('click', function () {
+        if (true === browser.trackLabelsVisible) {
+          self.doHide();
+        } else {
+          self.doShow();
+        }
+      });
+    };
+
+    TrackLabelControl.prototype.doHide = function () {
+      this.$button.removeClass('igv-navbar-button-clicked');
+      this.browser.hideTrackLabels();
+    };
+
+    TrackLabelControl.prototype.doShow = function () {
+      this.$button.addClass('igv-navbar-button-clicked');
+      this.browser.showTrackLabels();
+    };
+
+    TrackLabelControl.prototype.setState = function (trackLabelsVisible) {
+      if (true === trackLabelsVisible) {
+        this.$button.addClass('igv-navbar-button-clicked');
+      } else {
+        this.$button.removeClass('igv-navbar-button-clicked');
+      }
+    };
+
+    TrackLabelControl.prototype.disable = function () {
+      this.doHide();
+      this.$button.hide();
+    };
+
+    TrackLabelControl.prototype.enable = function () {
+      this.$button.show();
+    };
+
+    /*
+     * The MIT License (MIT)
+     *
+     * Copyright (c) 2016 University of California San Diego
+     * Author: Jim Robinson
+     *
+     * Permission is hereby granted, free of charge, to any person obtaining a copy
+     * of this software and associated documentation files (the "Software"), to deal
+     * in the Software without restriction, including without limitation the rights
+     * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+     * copies of the Software, and to permit persons to whom the Software is
+     * furnished to do so, subject to the following conditions:
+     *
+     * The above copyright notice and this permission notice shall be included in
+     * all copies or substantial portions of the Software.
+     *
+     *
+     * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+     * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+     * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+     * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+     * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+     * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+     * THE SOFTWARE.
+     */
+
+    class SampleNameControl {
+      constructor($parent, browser) {
+        this.$button = $('<div class="igv-navbar-button">');
+        $parent.append(this.$button);
+        this.$button.text('Sample Names');
+
+        if (true === browser.showSampleNames) {
+          this.$button.addClass('igv-navbar-button-clicked');
+        } else {
+          this.$button.removeClass('igv-navbar-button-clicked');
+        }
+
+        this.$button.on('click.sample-name-control', () => {
+          browser.showSampleNames = !browser.showSampleNames;
+
+          if (true === browser.showSampleNames) {
+            this.$button.addClass('igv-navbar-button-clicked');
+          } else {
+            this.$button.removeClass('igv-navbar-button-clicked');
+          }
+
+          for (let {
+            sampleNameViewport
+          } of browser.trackViews) {
+            if (false === browser.showSampleNames) {
+              sampleNameViewport.hide();
+            } else {
+              sampleNameViewport.show();
+            }
+          }
+
+          browser.resize();
+        });
+      }
+
+      setState(isVisible) {
+        if (true === isVisible) {
+          this.$button.addClass('igv-navbar-button-clicked');
+        } else {
+          this.$button.removeClass('igv-navbar-button-clicked');
+        }
+      }
+
+      hide() {
+        this.$button.hide();
+      }
+
+      show() {
+        this.$button.show();
+      }
+
+    }
+
+    /*
+     * The MIT License (MIT)
+     *
+     * Copyright (c) 2016 University of California San Diego
+     * Author: Jim Robinson
+     *
+     * Permission is hereby granted, free of charge, to any person obtaining a copy
+     * of this software and associated documentation files (the "Software"), to deal
+     * in the Software without restriction, including without limitation the rights
+     * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+     * copies of the Software, and to permit persons to whom the Software is
+     * furnished to do so, subject to the following conditions:
+     *
+     * The above copyright notice and this permission notice shall be included in
+     * all copies or substantial portions of the Software.
+     *
+     *
+     * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+     * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+     * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+     * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+     * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+     * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+     * THE SOFTWARE.
+     */
+
+    const SVGSaveControl = function ($parent, browser) {
+      let $button = $('<div class="igv-navbar-button">');
+      $parent.append($button);
+      $button.text('Save SVG');
+      $button.on('click.svg-save-control', () => {
+        // browser.renderSVG({ $container: $('#igv-svg-container') })
+        browser.saveSVGtoFile({});
+      });
+    };
+
+    /*
+     * The MIT License (MIT)
+     *
+     * Copyright (c) 2016 University of California San Diego
+     * Author: Jim Robinson
+     *
+     * Permission is hereby granted, free of charge, to any person obtaining a copy
+     * of this software and associated documentation files (the "Software"), to deal
+     * in the Software without restriction, including without limitation the rights
+     * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+     * copies of the Software, and to permit persons to whom the Software is
+     * furnished to do so, subject to the following conditions:
+     *
+     * The above copyright notice and this permission notice shall be included in
+     * all copies or substantial portions of the Software.
+     *
+     *
+     * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+     * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+     * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+     * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+     * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+     * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+     * THE SOFTWARE.
+     */
+
+    const ZoomWidget = function (browser, $parent) {
+      let $div;
+      this.$zoomContainer = $('<div class="igv-zoom-widget">');
+      $parent.append(this.$zoomContainer); // zoom out
+
+      $div = $('<div>');
+      this.$zoomContainer.append($div);
+      $div.append(createIcon$1("minus-circle"));
+      $div.on('click', function () {
+        browser.zoomOut();
+      }); // Range slider
+
+      $div = $('<div>');
+      this.$zoomContainer.append($div);
+      this.$slider = $('<input type="range"/>');
+      $div.append(this.$slider);
+      this.$slider.on('change', function (e) {
+        browser.zoomWithRangePercentage(e.target.value / 100.0);
+      }); // zoom in
+
+      $div = $('<div>');
+      this.$zoomContainer.append($div);
+      $div.append(createIcon$1("plus-circle"));
+      $div.on('click', function () {
+        browser.zoomIn();
+      });
+      this.currentChr = undefined;
+      let self = this;
+      browser.on('locuschange', function () {
+        browser.updateZoomSlider(self.$slider);
+      });
+    };
+
+    ZoomWidget.prototype.hide = function () {
+      this.$zoomContainer.hide();
+    };
+
+    ZoomWidget.prototype.show = function () {
+      this.$zoomContainer.show();
+    };
+
+    ZoomWidget.prototype.hideSlider = function () {
+      this.$slider.hide();
+    };
+
+    ZoomWidget.prototype.showSlider = function () {
+      this.$slider.show();
+    };
+
+    /*
+     * The MIT License (MIT)
+     *
+     * Copyright (c) 2014 Broad Institute
+     *
+     * Permission is hereby granted, free of charge, to any person obtaining a copy
+     * of this software and associated documentation files (the "Software"), to deal
+     * in the Software without restriction, including without limitation the rights
+     * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+     * copies of the Software, and to permit persons to whom the Software is
+     * furnished to do so, subject to the following conditions:
+     *
+     * The above copyright notice and this permission notice shall be included in
+     * all copies or substantial portions of the Software.
+     *
+     *
+     * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+     * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+     * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+     * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+     * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+     * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+     * THE SOFTWARE.
+     */
+
+    const UserFeedback = function ($parent) {
+      this.$container = $('<div class="igv-user-feedback">');
+      $parent.append(this.$container); // header
+
+      let $header = $('<div>');
+      this.$container.append($header); // alert
+
+      let $exclamation = $('<div>');
+      $header.append($exclamation);
+      let $a = createIcon$1("exclamation-triangle", 'red');
+      $exclamation.append($a); // dismiss
+
+      let $dismiss = $('<div>');
+      $header.append($dismiss);
+      let $b = createIcon$1("times-circle", 'grey');
+      $dismiss.append($b); // body copy
+
+      let $bodyCopyContainer = $('<div>');
+      this.$container.append($bodyCopyContainer);
+      let $bodyCopy = $('<div>');
+      $bodyCopyContainer.append($bodyCopy);
+      $bodyCopy.text('i am user feedback');
+      let self;
+      $dismiss.click(function () {
+        $bodyCopy.html('');
+        self.$container.hide();
+      });
+    };
+
+    UserFeedback.prototype.show = function () {
+      this.$container.show();
+    };
+
+    UserFeedback.prototype.hide = function () {
+      this.$container.hide();
+    };
+
+    /*
+     * The MIT License (MIT)
+     *
+     * Copyright (c) 2014 Broad Institute
+     *
+     * Permission is hereby granted, free of charge, to any person obtaining a copy
+     * of this software and associated documentation files (the "Software"), to deal
+     * in the Software without restriction, including without limitation the rights
+     * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+     * copies of the Software, and to permit persons to whom the Software is
+     * furnished to do so, subject to the following conditions:
+     *
+     * The above copyright notice and this permission notice shall be included in
+     * all copies or substantial portions of the Software.
+     *
+     *
+     * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+     * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+     * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+     * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+     * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+     * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+     * THE SOFTWARE.
+     */
+
+    const multiLocusGapDivWidth = 1;
+    const multiLocusGapMarginWidth = 2;
+    const multiLocusGapWidth = 2 * multiLocusGapMarginWidth + multiLocusGapDivWidth;
+    const rightHandGutterWidth = 36;
+    const trackManipulationHandleWidth = 12;
+    const trackManipulationHandleMarginWidth = 0;
+    const trackManipulationHandleShim = trackManipulationHandleWidth + trackManipulationHandleMarginWidth;
+    const scrollbarOuterWidth = 14; // igv.scss - $igv-viewport-container-shim-width
+
+    const viewportContainerShimWidth = rightHandGutterWidth + trackManipulationHandleShim + scrollbarOuterWidth;
+    const defaultSampleNameViewportWidth = 200;
+
+    class Browser {
+      constructor(config, parentDiv) {
+        this.config = config;
+        this.guid = guid();
+        this.namespace = '.browser_' + this.guid;
+        this.parent = parentDiv;
+        this.$root = $('<div>', {
+          class: 'igv-root'
+        });
+        $(parentDiv).append(this.$root);
+        const $trackContainer = $('<div>', {
+          class: 'igv-track-container'
+        });
+        this.$root.append($trackContainer);
+        Alert.init(this.$root.get(0));
+        this.trackContainer = $trackContainer.get(0);
+        this.initialize(config);
+        this.trackViews = [];
+        this.trackLabelsVisible = true;
+        this.isCenterGuideVisible = false;
+        this.showSampleNames = false;
+        this.cursorGuideVisible = false;
+        this.constants = {
+          dragThreshold: 3,
+          scrollThreshold: 5,
+          defaultColor: "rgb(0,0,150)",
+          doubleClickDelay: config.doubleClickDelay || 500
+        }; // Map of event name -> [ handlerFn, ... ]
+
+        this.eventHandlers = {};
+        this.$spinner = $('<div>', {
+          class: 'igv-track-container-spinner'
+        });
+        $trackContainer.append(this.$spinner);
+        this.$spinner.append(createIcon$1("spinner"));
+        this.stopSpinner();
+        this.addMouseHandlers();
+        this.setControls(config);
+      }
+
+      initialize(config) {
+
+        if (config.gtex) {
+          GtexUtils.gtexLoaded = true;
+        }
+
+        this.flanking = config.flanking;
+        this.crossDomainProxy = config.crossDomainProxy;
+        this.formats = config.formats;
+        this.trackDefaults = config.trackDefaults;
+        this.nucleotideColors = config.nucleotideColors || defaultNucleotideColors;
+
+        for (let key of Object.keys(this.nucleotideColors)) {
+          this.nucleotideColors[key.toLowerCase()] = this.nucleotideColors[key];
+        }
+
+        this.showSampleNames = config.showSampleNames;
+        this.showSampleNameButton = config.showSampleNameButton;
+        this.sampleNameViewportWidth = config.sampleNameViewportWidth || defaultSampleNameViewportWidth;
+
+        if (config.search) {
+          this.searchConfig = {
+            type: "json",
+            url: config.search.url,
+            coords: config.search.coords === undefined ? 1 : config.search.coords,
+            chromosomeField: config.search.chromosomeField || "chromosome",
+            startField: config.search.startField || "start",
+            endField: config.search.endField || "end",
+            geneField: config.search.geneField || "gene",
+            snpField: config.search.snpField || "snp",
+            resultsField: config.search.resultsField
+          };
+        }
+      }
+
+      setControls(config) {
+        const $navBar = this.createStandardControls(config);
+        $navBar.insertBefore($(this.trackContainer));
+
+        if (false === config.showControls) {
+          $navBar.hide();
+        }
+
+        if (false === config.showTrackLabels) {
+          this.hideTrackLabels();
+        } else {
+          this.showTrackLabels();
+
+          if (this.trackLabelControl) {
+            this.trackLabelControl.setState(this.trackLabelsVisible);
+          }
+        }
+
+        if (false === config.showCursorTrackingGuide) {
+          this.cursorGuide.doHide();
+        } else {
+          this.cursorGuide.doShow();
+        }
+
+        if (false === config.showCenterGuide) {
+          this.centerGuide.doHide();
+        } else {
+          this.centerGuide.doShow();
+        }
+      }
+
+      createStandardControls(config) {
+        this.navbarManager = new NavbarManager(this);
+        const $navBar = $('<div>', {
+          class: 'igv-navbar'
+        });
+        this.$navigation = $navBar;
+        const $navbarLeftContainer = $('<div>', {
+          class: 'igv-navbar-left-container'
+        });
+        $navBar.append($navbarLeftContainer); // IGV logo
+
+        const $logo = $('<div>', {
+          class: 'igv-logo'
+        });
+        $navbarLeftContainer.append($logo);
+        const logoSvg = logo();
+        logoSvg.css("width", "34px");
+        logoSvg.css("height", "32px");
+        $logo.append(logoSvg);
+        this.$current_genome = $('<div>', {
+          class: 'igv-current-genome'
+        });
+        $navbarLeftContainer.append(this.$current_genome);
+        this.$current_genome.text('');
+        const $genomicLocation = $('<div>', {
+          class: 'igv-navbar-genomic-location'
+        });
+        $navbarLeftContainer.append($genomicLocation); // chromosome select widget
+
+        if (config.showChromosomeWidget !== false) {
+          this.chromosomeSelectWidget = new ChromosomeSelectWidget(this, $genomicLocation);
+          this.chromosomeSelectWidget.$container.show();
+        }
+
+        const $locusSizeGroup = $('<div>', {
+          class: 'igv-locus-size-group'
+        });
+        $genomicLocation.append($locusSizeGroup);
+        const $searchContainer = $('<div>', {
+          class: 'igv-search-container'
+        });
+        $locusSizeGroup.append($searchContainer); // browser.$searchInput = $('<input type="text" placeholder="Locus Search">');
+
+        this.$searchInput = $('<input>', {
+          class: 'igv-search-input',
+          type: 'text',
+          placeholder: 'Locus Search'
+        });
+        $searchContainer.append(this.$searchInput);
+        this.$searchInput.change(async () => {
+          try {
+            const str = this.$searchInput.val();
+            const referenceFrameList = await this.search(str);
+
+            if (referenceFrameList.length > 1) {
+              this.updateLocusSearchWidget(referenceFrameList);
+              this.windowSizePanel.updatePanel(referenceFrameList);
+            }
+          } catch (error) {
+            Alert.presentAlert(error);
+          }
+        });
+        const $searchIconContainer = $('<div>', {
+          class: 'igv-search-icon-container'
+        });
+        $searchContainer.append($searchIconContainer);
+        $searchIconContainer.append(createIcon$1("search"));
+        $searchIconContainer.on('click', () => this.search(this.$searchInput.val()));
+        this.windowSizePanel = new WindowSizePanel($locusSizeGroup, this);
+        const $navbarRightContainer = $('<div>', {
+          class: 'igv-navbar-right-container'
+        });
+        $navBar.append($navbarRightContainer);
+        const $toggle_button_container = $('<div class="igv-navbar-toggle-button-container">');
+        $navbarRightContainer.append($toggle_button_container);
+        this.$toggle_button_container = $toggle_button_container;
+        this.cursorGuide = new CursorGuide($(this.trackContainer), $toggle_button_container, config, this);
+        this.centerGuide = new CenterGuide($(this.trackContainer), $toggle_button_container, config, this);
+
+        if (true === config.showTrackLabelButton) {
+          this.trackLabelControl = new TrackLabelControl($toggle_button_container, this);
+        } // if (true === config.showSampleNameButton) {
+
+
+        this.sampleNameControl = new SampleNameControl($toggle_button_container, this);
+
+        if (!config.showSampleNameButton) {
+          this.sampleNameControl.hide();
+        } //  }
+
+
+        if (true === config.showSVGButton) {
+          this.svgSaveControl = new SVGSaveControl($toggle_button_container, this);
+        }
+
+        this.zoomWidget = new ZoomWidget(this, $navbarRightContainer);
+
+        if (false === config.showNavigation) {
+          this.$navigation.hide();
+        }
+
+        this.userFeedback = new UserFeedback($(this.trackContainer));
+        this.userFeedback.hide();
+        this.inputDialog = new InputDialog(this.$root.get(0));
+        this.dataRangeDialog = new DataRangeDialog(this.$root);
+        return $navBar;
+      }
+
+      getSampleNameViewportWidth() {
+        return false === this.showSampleNames ? 0 : this.sampleNameViewportWidth;
+      }
+
+      startSpinner() {
+        const $spinner = this.$spinner;
+
+        if ($spinner) {
+          $spinner.addClass("igv-fa5-spin");
+          $spinner.show();
+        }
+      }
+
+      stopSpinner() {
+        const $spinner = this.$spinner;
+
+        if ($spinner) {
+          $spinner.hide();
+          $spinner.removeClass("igv-fa5-spin");
+        }
+      }
+
+      isMultiLocusMode() {
+        return this.referenceFrameList && this.referenceFrameList.length > 1;
+      }
+
+      addTrackToFactory(name, track) {
+        TrackFactory.addTrack(name, track);
+      }
+
+      isMultiLocusWholeGenomeView() {
+        if (undefined === this.referenceFrameList || 1 === this.referenceFrameList.length) {
+          return false;
+        }
+
+        for (let referenceFrame of this.referenceFrameList) {
+          if ('all' === referenceFrame.chr.toLowerCase()) {
+            return true;
+          }
+        }
+
+        return false;
+      }
+
+      /**
+       * Render browse display as SVG
+       * @returns {string}
+       */
+      async toSVG() {
+        let {
+          x,
+          y,
+          width,
+          height
+        } = this.trackContainer.getBoundingClientRect();
+        const {
+          x: vpx
+        } = this.trackViews[0].$viewportContainer.get(0).getBoundingClientRect();
+        width += (this.referenceFrameList.length - 1) * multiLocusGapWidth;
+        const h_render = 8000;
+        let svgContext = new C2S({
+          width,
+          height: h_render,
+          backdropColor: 'white',
+          multiLocusGap: multiLocusGapWidth,
+          viewbox: {
+            x: 0,
+            y: 0,
+            width,
+            height: h_render
+          }
+        });
+        const dx = vpx - x; // tracks -> SVG
+
+        for (let trackView of this.trackViews) {
+          trackView.renderSVGContext(svgContext, {
+            deltaX: dx,
+            deltaY: -y
+          });
+        } // reset height to trim away unneeded svg canvas real estate. Yes, a bit of a hack.
+
+
+        svgContext.setHeight(height);
+        return svgContext.getSerializedSvg(true);
+      }
+
+      async saveSVGtoFile(config) {
+        let svg = await this.toSVG();
+
+        if (config.$container) {
+          const trackContainerBBox = this.trackContainer.getBoundingClientRect();
+          config.$container.empty();
+          config.$container.width(trackContainerBBox.width);
+          config.$container.append(svg);
+        }
+
+        const path = config.filename || 'igv.svg';
+        const data = URL.createObjectURL(new Blob([svg], {
+          type: "application/octet-stream"
+        }));
+        download(path, data);
+      }
+      /**
+       * Initialize a session from an object, json, or by loading from a file.
+       *
+       * TODO Really should be split into at least 2 functions, load from file and load from object/json
+       *
+       * @param options
+       * @returns {*}
+       */
+
+
+      async loadSession(options) {
+        this.roi = [];
+        let session;
+
+        if (options.url || options.file) {
+          session = await loadSessionFile(options);
+        } else {
+          session = options;
+        }
+
+        return this.loadSessionObject(session);
+
+        async function loadSessionFile(options) {
+          const urlOrFile = options.url || options.file;
+
+          if (options.url && (options.url.startsWith("blob:") || options.url.startsWith("data:"))) {
+            const json = Browser.uncompressSession(options.url);
+            return JSON.parse(json);
+          } else {
+            let filename = options.filename;
+
+            if (!filename) {
+              filename = options.url ? await getFilename(options.url) : options.file.name;
+            }
+
+            if (filename.endsWith(".xml")) {
+              const knownGenomes = GenomeUtils.KNOWN_GENOMES;
+              const string = await igvxhr.loadString(urlOrFile);
+              return new XMLSession(string, knownGenomes);
+            } else if (filename.endsWith(".json")) {
+              return igvxhr.loadJson(urlOrFile);
+            } else {
+              return undefined;
+            }
+          }
+        }
+      }
+      /**
+       * Note:  public API function
+       * @param session
+       * @returns {Promise<void>}
+       */
+
+
+      async loadSessionObject(session) {
+        this.removeAllTracks();
+        this.showSampleNames = session.showSampleNames || false;
+        this.sampleNameControl.setState(this.showSampleNames === true);
+
+        if (session.sampleNameViewportWidth) {
+          this.sampleNameViewportWidth = session.sampleNameViewportWidth;
+        }
+
+        const genomeConfig = await GenomeUtils.expandReference(session.reference || session.genome);
+        const genome = await this.loadReference(genomeConfig, session.locus); // Create ideogram and ruler track.  Really this belongs in browser initialization, but creation is
+        // deferred because ideogram and ruler are treated as "tracks", and tracks require a reference frame
+
+        if (undefined === this.ideogram && false !== this.config.showIdeogram) {
+          this.ideogram = new IdeogramTrack(this);
+          this.addTrack(this.ideogram);
+        }
+
+        if (undefined === this.rulerTrack && false !== this.config.showRuler) {
+          this.rulerTrack = new RulerTrack(this);
+          this.addTrack(this.rulerTrack);
+        } // Restore gtex selections.
+
+
+        if (session.gtexSelections) {
+          for (let referenceFrame of this.referenceFrameList) {
+            for (let s of Object.keys(session.gtexSelections)) {
+              const gene = session.gtexSelections[s].gene;
+              const snp = session.gtexSelections[s].snp;
+              referenceFrame.selection = new GtexSelection(gene, snp);
+            }
+          }
+        }
+
+        if (session.roi) {
+          this.roi = [];
+
+          for (let r of session.roi) {
+            this.roi.push(new ROI(r, genome));
+          }
+        } // Tracks.  Start with genome tracks, if any, then append session tracks
+
+
+        const genomeTracks = genomeConfig.tracks || [];
+        const tracks = session.tracks ? genomeTracks.concat(session.tracks) : genomeTracks; // Insure that we always have a sequence track
+
+        const pushSequenceTrack = tracks.filter(track => track.type === 'sequence').length === 0;
+
+        if (pushSequenceTrack && false !== this.config.showSequence) {
+          tracks.push({
+            type: "sequence",
+            order: defaultSequenceTrackOrder
+          });
+        } // Maintain track order unless explicitly set
+
+
+        let trackOrder = 1;
+
+        for (let t of tracks) {
+          if (undefined === t.order) {
+            t.order = trackOrder++;
+          }
+        }
+
+        await this.loadTrackList(tracks);
+
+        if (this.ideogram) {
+          this.ideogram.trackView.updateViews();
+        }
+
+        if (this.rulerTrack) {
+          this.rulerTrack.trackView.updateViews();
+        }
+
+        if (this.centerGuide) {
+          this.centerGuide.repaint();
+        }
+
+        this.updateLocusSearchWidget(this.referenceFrameList);
+        this.windowSizePanel.updatePanel(this.referenceFrameList);
+      }
+      /**
+       * Load a genome, defined by a string ID or a json-like configuration object. This includes a fasta reference
+       * as well as optional cytoband and annotation tracks.
+       *
+       * @param idOrConfig
+       * @returns {Promise<void>}
+       */
+
+
+      async loadGenome(idOrConfig) {
+        const genomeConfig = await GenomeUtils.expandReference(idOrConfig);
+        const genome = await this.loadReference(genomeConfig);
+        const tracks = genomeConfig.tracks || []; // Insure that we always have a sequence track
+
+        const pushSequenceTrack = tracks.filter(track => track.type === 'sequence').length === 0;
+
+        if (pushSequenceTrack) {
+          tracks.push({
+            type: "sequence",
+            order: defaultSequenceTrackOrder
+          });
+        }
+
+        await this.loadTrackList(tracks);
+        this.updateViews();
+        return genome;
+      }
+      /**
+       * Load a reference genome object.  This includes the fasta, and optional cytoband, but no tracks.  This method
+       * is used by loadGenome and loadSession.
+       *
+       * @param genomeConfig
+       * @param initialLocus
+       * @returns {Promise<void>}
+       */
+
+
+      async loadReference(genomeConfig, initialLocus) {
+        const genome = await GenomeUtils.loadGenome(genomeConfig);
+        const genomeChange = this.genome && this.genome.id !== genome.id;
+        this.genome = genome;
+        this.$current_genome.text(genome.id || '');
+        this.$current_genome.attr('title', genome.id || '');
+
+        if (this.chromosomeSelectWidget) {
+          this.chromosomeSelectWidget.update(genome);
+        }
+
+        if (genomeChange) {
+          this.removeAllTracks();
+        }
+
+        this.genome = genome;
+
+        try {
+          this.referenceFrameList = await this.search(getInitialLocus(initialLocus, genome), true);
+        } catch (error) {
+          // Couldn't find initial locus
+          Alert.presentAlert(new Error(`Error searching for locus ${initialLocus}  [${error}]`), undefined);
+          this.referenceFrameList = await this.search(this.genome.getHomeChromosomeName());
+        }
+
+        return this.genome;
+
+        function getInitialLocus(locus, genome) {
+          let loci = [];
+
+          if (locus) {
+            if (Array.isArray(locus)) {
+              loci = locus.join(' ');
+            } else {
+              loci = locus;
+            }
+          } else {
+            loci = genome.getHomeChromosomeName();
+          }
+
+          return loci;
+        }
+      } //
+
+
+      updateUIWithReferenceFrameListChange(referenceFrameList) {
+        const isWGV = this.isMultiLocusWholeGenomeView() || GenomeUtils.isWholeGenomeView(referenceFrameList[0].chr);
+
+        if (isWGV || this.isMultiLocusMode()) {
+          this.centerGuide.forcedHide();
+        } else {
+          this.centerGuide.forcedShow();
+        }
+
+        this.navbarManager.navbarDidResize(this.$navigation.width(), isWGV);
+        toggleTrackLabels(this.trackViews, this.trackLabelsVisible);
+      }
+
+      // track labels
+      setTrackLabelName(trackView, name) {
+        trackView.viewports.forEach(viewport => {
+          viewport.setTrackLabel(name);
+        });
+      }
+
+      hideTrackLabels() {
+        this.trackLabelsVisible = false;
+        toggleTrackLabels(this.trackViews, this.trackLabelsVisible);
+      }
+
+      showTrackLabels() {
+        this.trackLabelsVisible = true;
+        toggleTrackLabels(this.trackViews, this.trackLabelsVisible);
+      }
+
+      // cursor guide
+      hideCursorGuide() {
+        this.cursorGuide.$verticalGuide.hide();
+        this.cursorGuide.$horizontalGuide.hide();
+        this.cursorGuideVisible = false;
+      }
+
+      showCursorGuide() {
+        this.cursorGuide.$verticalGuide.show();
+        this.cursorGuide.$horizontalGuide.show();
+        this.cursorGuideVisible = true;
+      }
+
+      setCustomCursorGuideMouseHandler(mouseHandler) {
+        this.cursorGuide.customMouseHandler = mouseHandler;
+      }
+
+      // center guide
+      hideCenterGuide() {
+        this.centerGuide.$container.hide();
+        this.isCenterGuideVisible = false;
+      }
+
+      showCenterGuide() {
+        this.centerGuide.$container.show();
+        this.centerGuide.resize();
+        this.isCenterGuideVisible = true;
+      }
+
+      async loadTrackList(configList) {
+        try {
+          this.startSpinner();
+          const promises = [];
+
+          for (let config of configList) {
+            const noSpinner = true;
+            promises.push(this.loadTrack(config, noSpinner));
+          }
+
+          const loadedTracks = await Promise.all(promises);
+          const groupAutoscaleViews = this.trackViews.filter(function (trackView) {
+            return trackView.track.autoscaleGroup;
+          });
+
+          if (groupAutoscaleViews.length > 0) {
+            this.updateViews(this.referenceFrameList[0], groupAutoscaleViews);
+          }
+
+          return loadedTracks;
+        } finally {
+          this.stopSpinner();
+        }
+      }
+
+      async loadROI(config) {
+        if (!this.roi) {
+          this.roi = [];
+        }
+
+        if (Array.isArray(config)) {
+          for (let c of config) {
+            this.roi.push(new ROI(c, this.genome));
+          }
+        } else {
+          this.roi.push(new ROI(config, this.genome));
+        }
+
+        await this.updateViews(undefined, undefined, true);
+      }
+
+      removeROI(roiToRemove) {
+        for (let i = 0; i < this.roi.length; i++) {
+          if (this.roi[i].name === roiToRemove.name) {
+            this.roi.splice(i, 1);
+            break;
+          }
+        }
+
+        for (let tv of this.trackViews) {
+          tv.updateViews(undefined, undefined, true);
+        }
+      }
+
+      clearROIs() {
+        this.roi = [];
+
+        for (let tv of this.trackViews) {
+          tv.updateViews(undefined, undefined, true);
+        }
+      }
+      /**
+       * Return a promise to load a track
+       *
+       * @param config
+       * @returns {*}
+       */
+
+
+      async loadTrack(config, noSpinner) {
+        // config might be json
+        if (isString$6(config)) {
+          config = JSON.parse(config);
+        }
+
+        try {
+          if (!noSpinner) this.startSpinner();
+          const newTrack = await this.createTrack(config);
+
+          if (undefined === newTrack) {
+            Alert.presentAlert(new Error(`Unknown file type: ${config.url || config}`), undefined);
+            return newTrack;
+          } // Set order field of track here.  Otherwise track order might get shuffled during asynchronous load
+
+
+          if (undefined === newTrack.order) {
+            newTrack.order = this.trackViews.length;
+          }
+
+          if (typeof newTrack.postInit === 'function') {
+            await newTrack.postInit();
+          }
+
+          if (config.sync) {
+            await this.addTrack(newTrack);
+          } else {
+            this.addTrack(newTrack);
+          }
+
+          if (typeof newTrack.hasSamples === 'function' && newTrack.hasSamples()) {
+            if (this.config.showSampleNameButton !== false) {
+              this.sampleNameControl.show(); // If not explicitly set
+            }
+          }
+
+          return newTrack;
+        } catch (error) {
+          const httpMessages = {
+            "401": "Access unauthorized",
+            "403": "Access forbidden",
+            "404": "Not found"
+          };
+          console.error(error);
+          let msg = error.message || error.error || error.toString();
+
+          if (httpMessages.hasOwnProperty(msg)) {
+            msg = httpMessages[msg];
+          }
+
+          msg += ": " + config.url;
+          Alert.presentAlert(new Error(msg), undefined);
+        } finally {
+          if (!noSpinner) {
+            this.stopSpinner();
+          }
+        }
+      }
+
+      async createTrack(config) {
+        // Resolve function and promise urls
+        let url = await resolveURL(config.url);
+
+        if (isString$6(url)) {
+          url = url.trim();
+        }
+
+        if (url) {
+          if (config.format) {
+            config.format = config.format.toLowerCase();
+          } else {
+            let filename = config.filename;
+
+            if (!filename) {
+              filename = await getFilename(url);
+            }
+
+            config.format = inferFileFormat(filename);
+
+            if (!config.format && (config.sourceType === undefined || config.sourceType === "htsget")) {
+              // Check for htsget URL.  This is a longshot
+              await HtsgetReader.inferFormat(config);
+            }
+          }
+        }
+
+        let type = config.type;
+
+        if (type) {
+          type = type.toLowerCase();
+        } else {
+          type = inferTrackType(config);
+          config.type = type;
+        }
+
+        if ("bedtype" === type) {
+          // Bed files must be read to determine track type
+          const featureSource = FeatureSource(config, this.genome);
+          config._featureSource = featureSource; // This is a temp variable, bit of a hack
+
+          const trackType = await featureSource.trackType();
+
+          if (trackType) {
+            type = trackType;
+          } else {
+            type = "annotation";
+          } // Record in config to make type persistent in session
+
+
+          config.type = type;
+        } // Set defaults if specified
+
+
+        if (this.trackDefaults && type) {
+          const settings = this.trackDefaults[type];
+
+          if (settings) {
+            for (let property in settings) {
+              if (settings.hasOwnProperty(property) && config[property] === undefined) {
+                config[property] = settings[property];
+              }
+            }
+          }
+        }
+
+        let track;
+
+        switch (type) {
+          case "annotation":
+          case "genes":
+          case "fusionjuncspan":
+          case "junctions":
+          case "splicejunctions":
+          case "snp":
+            track = TrackFactory.getTrack("feature")(config, this);
+            break;
+
+          default:
+            if (TrackFactory.tracks.hasOwnProperty(type)) {
+              track = TrackFactory.getTrack(type)(config, this);
+            } else {
+              track = undefined;
+            }
+
+        }
+
+        if (config.roi && track) {
+          track.roi = [];
+
+          for (let r of config.roi) {
+            track.roi.push(new ROI(r, this.genome));
+          }
+        }
+
+        return track;
+      }
+      /**
+       * Add a new track.  Each track is associated with the following DOM elements
+       *
+       *      leftHandGutter  - div on the left for track controls and legend
+       *      contentDiv  - a div element wrapping all the track content.  Height can be > viewportDiv height
+       *      viewportDiv - a div element through which the track is viewed.  This might have a vertical scrollbar
+       *      canvas     - canvas element upon which the track is drawn.  Child of contentDiv
+       *
+       * The width of all elements should be equal.  Height of the viewportDiv is controlled by the user, but never
+       * greater than the contentDiv height.   Height of contentDiv and canvas are equal, and governed by the data
+       * loaded.
+       *
+       * @param track
+       */
+
+
+      async addTrack(track) {
+        var trackView;
+        trackView = new TrackView(this, $(this.trackContainer), track);
+        this.trackViews.push(trackView);
+        toggleTrackLabels(this.trackViews, this.trackLabelsVisible);
+        this.reorderTracks();
+        this.fireEvent('trackorderchanged', [this.getTrackOrder()]);
+
+        if (!track.autoscaleGroup) {
+          // Group autoscale groups will get updated later (as a group)
+          return trackView.updateViews();
+        }
+      }
+
+      reorderTracks() {
+        this.trackViews.sort(function (a, b) {
+          const firstSortOrder = tv => {
+            return 'ideogram' === tv.track.id ? 1 : 'ruler' === tv.track.id ? 2 : 3;
+          };
+
+          const aOrder1 = firstSortOrder(a);
+          const bOrder1 = firstSortOrder(b);
+
+          if (aOrder1 === bOrder1) {
+            const aOrder2 = a.track.order || 0;
+            const bOrder2 = b.track.order || 0;
+            return aOrder2 - bOrder2;
+          } else {
+            return aOrder1 - bOrder1;
+          }
+        }); // Reattach the divs to the dom in the correct order
+
+        $(this.trackContainer).children("igv-track").detach();
+
+        for (let trackView of this.trackViews) {
+          this.trackContainer.appendChild(trackView.trackDiv);
+        }
+      }
+
+      getTrackOrder() {
+        return this.trackViews.filter(tv => tv.track && tv.track.name).map(tv => tv.track.name);
+      }
+
+      removeTrackByName(name) {
+        const copy = this.trackViews.slice();
+
+        for (let trackView of copy) {
+          if (name === trackView.track.name) {
+            this.removeTrack(trackView.track);
+          }
+        }
+      }
+
+      removeTrack(track) {
+        // Find track panel
+        var trackPanelRemoved;
+
+        for (var i = 0; i < this.trackViews.length; i++) {
+          if (track === this.trackViews[i].track) {
+            trackPanelRemoved = this.trackViews[i];
+            break;
+          }
+        }
+
+        if (trackPanelRemoved) {
+          this.trackViews.splice(i, 1);
+          $(trackPanelRemoved.trackDiv).remove();
+          this.fireEvent('trackremoved', [trackPanelRemoved.track]);
+          this.fireEvent('trackorderchanged', [this.getTrackOrder()]);
+          trackPanelRemoved.dispose();
+        }
+      }
+
+      /**
+       * API function
+       */
+      removeAllTracks() {
+        const newTrackViews = [];
+
+        for (let trackView of this.trackViews) {
+          const trackId = trackView.track.id;
+
+          if (trackId !== 'ruler' && trackId !== 'ideogram') {
+            this.trackContainer.removeChild(trackView.trackDiv);
+            this.fireEvent('trackremoved', [trackView.track]);
+            trackView.dispose();
+          } else {
+            newTrackViews.push(trackView);
+          }
+        }
+
+        this.trackViews = newTrackViews;
+      }
+      /**
+       *
+       * @param property
+       * @param value
+       * @returns {Array}  tracks with given property value.  e.g. findTracks("type", "annotation")
+       */
+
+
+      findTracks(property, value) {
+        let f = typeof property === 'function' ? trackView => property(trackView.track) : trackView => value === trackView.track[property];
+        return this.trackViews.filter(f).map(tv => tv.track);
+      }
+
+      setTrackHeight(newHeight) {
+        this.trackHeight = newHeight;
+        this.trackViews.forEach(function (trackView) {
+          trackView.setTrackHeight(newHeight);
+        });
+      }
+
+      async visibilityChange() {
+        const status = this.referenceFrameList.find(referenceFrame => referenceFrame.bpPerPixel < 0);
+
+        if (status) {
+          const viewportWidth = this.computeViewportWidth(this.referenceFrameList.length, this.getViewportContainerWidth());
+
+          for (let referenceFrame of this.referenceFrameList) {
+            referenceFrame.bpPerPixel = (referenceFrame.initialEnd - referenceFrame.start) / viewportWidth;
+          }
+        }
+
+        if (this.referenceFrameList) {
+          const isWGV = this.isMultiLocusWholeGenomeView() || GenomeUtils.isWholeGenomeView(this.referenceFrameList[0].chr);
+
+          if (isWGV || this.isMultiLocusMode()) {
+            this.centerGuide.forcedHide();
+          } else {
+            this.centerGuide.forcedShow();
+          }
+
+          this.navbarManager.navbarDidResize(this.$navigation.width(), isWGV);
+        }
+
+        await this.resize();
+      }
+
+      async resize() {
+        const viewportWidth = this.computeViewportWidth(this.referenceFrameList.length, this.getViewportContainerWidth());
+
+        for (let referenceFrame of this.referenceFrameList) {
+          const viewportWidthBP = referenceFrame.toBP(viewportWidth);
+          const {
+            bpLength
+          } = this.genome.getChromosome(referenceFrame.chr);
+
+          if (viewportWidthBP > bpLength) {
+            // console.log(`viewport-length-bp ${ StringUtils.numberFormatter(Math.round(viewportWidthBP))} chr-length-bp ${ StringUtils.numberFormatter(Math.round(bpLength)) }`)
+            referenceFrame.bpPerPixel = bpLength / viewportWidth;
+          }
+        } // console.log(`${ Date.now() } - browser - resize`)
+
+
+        if (this.centerGuide) this.centerGuide.resize();
+
+        for (let trackView of this.trackViews) {
+          trackView.resize(viewportWidth);
+        }
+
+        if (this.centerGuide) this.centerGuide.resize();
+
+        if (this.referenceFrameList && this.referenceFrameList.length > 0) {
+          this.updateLocusSearchWidget(this.referenceFrameList);
+          this.windowSizePanel.updatePanel(this.referenceFrameList);
+        }
+
+        await this.updateViews();
+
+        for (let {
+          viewports,
+          $viewportContainer
+        } of this.trackViews) {
+          updateViewportShims(viewports, $viewportContainer);
+        }
+      }
+
+      async updateViews(referenceFrame, trackViews, force) {
+        if (!trackViews) {
+          trackViews = this.trackViews;
+        }
+
+        if (!referenceFrame && this.referenceFrameList && 1 === this.referenceFrameList.length) {
+          referenceFrame = this.referenceFrameList[0];
+        }
+
+        if (referenceFrame) {
+          if (this.referenceFrameList.length > 1) {
+            this.updateLocusSearchWidget(this.referenceFrameList);
+            this.windowSizePanel.updatePanel(this.referenceFrameList);
+          } else {
+            this.updateLocusSearchWidget([referenceFrame]);
+            this.windowSizePanel.updatePanel([referenceFrame]);
+          }
+        }
+
+        if (this.centerGuide) {
+          this.centerGuide.repaint();
+        } // Don't autoscale while dragging.
+
+
+        if (this.dragObject) {
+          for (let trackView of trackViews) {
+            await trackView.updateViews(force);
+          }
+        } else {
+          // Group autoscale
+          const groupAutoscaleTracks = {};
+          const otherTracks = [];
+
+          for (let trackView of trackViews) {
+            const group = trackView.track.autoscaleGroup;
+
+            if (group) {
+              var l = groupAutoscaleTracks[group];
+
+              if (!l) {
+                l = [];
+                groupAutoscaleTracks[group] = l;
+              }
+
+              l.push(trackView);
+            } else {
+              otherTracks.push(trackView);
+            }
+          }
+
+          const keys = Object.keys(groupAutoscaleTracks);
+
+          for (let group of keys) {
+            const groupTrackViews = groupAutoscaleTracks[group];
+            const promises = [];
+
+            for (let trackView of groupTrackViews) {
+              promises.push(trackView.getInViewFeatures());
+            }
+
+            const featureArray = await Promise.all(promises);
+            var allFeatures = [],
+                dataRange;
+
+            for (let features of featureArray) {
+              allFeatures = allFeatures.concat(features);
+            }
+
+            dataRange = doAutoscale(allFeatures);
+
+            for (let trackView of groupTrackViews) {
+              trackView.track.dataRange = dataRange;
+              trackView.track.autoscale = false;
+              await trackView.updateViews(force);
+            }
+          }
+
+          for (let trackView of otherTracks) {
+            await trackView.updateViews(force);
+          }
+        }
+      }
+
+      loadInProgress() {
+        var i;
+
+        for (i = 0; i < this.trackViews.length; i++) {
+          if (this.trackViews[i].isLoading()) return true;
+        }
+
+        return false;
+      }
+
+      updateLocusSearchWidget(referenceFrameList) {
+        if (referenceFrameList.length > 1) {
+          this.$searchInput.val('');
+
+          if (this.chromosomeSelectWidget) {
+            this.chromosomeSelectWidget.$select.val('');
+          }
+
+          return;
+        }
+
+        if (this.rulerTrack) {
+          this.rulerTrack.updateLocusLabel();
+        }
+
+        const referenceFrame = referenceFrameList[0];
+
+        if (referenceFrame.locusSearchString && 'all' === referenceFrame.locusSearchString.toLowerCase()) {
+          this.$searchInput.val(referenceFrame.locusSearchString);
+
+          if (this.chromosomeSelectWidget) {
+            this.chromosomeSelectWidget.$select.val('all');
+          }
+        } else {
+          if (this.chromosomeSelectWidget) {
+            this.chromosomeSelectWidget.$select.val(referenceFrame.chr);
+          }
+
+          let ss;
+          let ee;
+          let str;
+
+          if (this.$searchInput) {
+            let end = referenceFrame.start + referenceFrame.bpPerPixel * this.getViewportWidth();
+
+            if (this.genome) {
+              const chromosome = this.genome.getChromosome(referenceFrame.chr);
+
+              if (chromosome) {
+                end = Math.min(end, chromosome.bpLength);
+              }
+            }
+
+            ss = numberFormatter$1(Math.floor(referenceFrame.start + 1));
+            ee = numberFormatter$1(Math.floor(end));
+            str = referenceFrame.chr + ":" + ss + "-" + ee;
+            this.$searchInput.val(str);
+          }
+
+          this.fireEvent('locuschange', [{
+            chr: referenceFrame.chr,
+            start: ss,
+            end: ee,
+            label: str
+          }]);
+        }
+      }
+
+      /**
+       * Return the visible width of a track.  All tracks should have the same width.
+       */
+      getViewportContainerWidth() {
+        let ww;
+
+        if (this.trackViews && this.trackViews.length > 0) {
+          ww = this.trackViews[0].$viewportContainer.width();
+        } else {
+          const {
+            width
+          } = this.trackContainer.getBoundingClientRect();
+          ww = width - viewportContainerShimWidth;
+        }
+
+        return ww;
+      }
+
+      computeViewportWidth(referenceFrameListLength, viewportContainerWidth) {
+        const containerWidth = TrackView.computeViewportWidth(this, viewportContainerWidth);
+        return 1 === referenceFrameListLength ? containerWidth : Math.floor((containerWidth - (referenceFrameListLength - 1) * multiLocusGapWidth) / referenceFrameListLength);
+      }
+
+      getViewportWidth() {
+        return this.trackViews[0].viewports[0].$viewport.width();
+      }
+
+      minimumBases() {
+        return this.config.minimumBases;
+      }
+
+      updateZoomSlider($slider) {
+        const viewport = this.trackViews[0].viewports[0];
+        const referenceFrame = viewport.referenceFrame;
+        const window = viewport.$viewport.width() * referenceFrame.bpPerPixel;
+        const maxWindow = referenceFrame.getChromosome().bpLength;
+        const minWindow = this.minimumBases();
+        const v = (maxWindow - window) / (maxWindow - minWindow);
+        const value = Math.round(100 * v);
+        $slider.val(value);
+      }
+
+      zoom(scaleFactor) {
+        this.zoomWithScaleFactor(scaleFactor);
+      }
+
+      // Zoom in by a factor of 2, keeping the same center location
+      zoomIn() {
+        this.zoomWithScaleFactor(0.5);
+      }
+
+      // Zoom out by a factor of 2, keeping the same center location if possible
+      zoomOut() {
+        this.zoomWithScaleFactor(2.0);
+      }
+
+      zoomWithRangePercentage(percentage) {
+        if (this.loadInProgress()) {
+          return;
+        }
+
+        const viewports = this.trackViews[0].viewports;
+
+        for (let viewport of viewports) {
+          const referenceFrame = viewport.referenceFrame;
+          const centerBP = referenceFrame.start + referenceFrame.toBP(viewport.$viewport.width() / 2.0);
+          const chromosome = referenceFrame.getChromosome();
+          const bpp = lerp((chromosome.bpLength - chromosome.bpStart) / viewport.$viewport.width(), this.minimumBases() / viewport.$viewport.width(), percentage);
+          const viewportWidthBP = bpp * viewport.$viewport.width();
+          referenceFrame.start = centerBP - viewportWidthBP / 2;
+          referenceFrame.bpPerPixel = bpp;
+          referenceFrame.clamp(viewport.$viewport.width());
+          this.updateViews(viewport.referenceFrame);
+
+          function lerp(v0, v1, t) {
+            return (1 - t) * v0 + t * v1;
+          }
+        }
+      }
+
+      zoomWithScaleFactor(scaleFactor, centerBPOrUndefined, viewportOrUndefined) {
+        let viewports = viewportOrUndefined ? [viewportOrUndefined] : this.trackViews[0].viewports;
+
+        for (let viewport of viewports) {
+          const referenceFrame = viewport.referenceFrame;
+          const chromosome = referenceFrame.getChromosome();
+          const start = referenceFrame.start;
+          const bpPerPixel = referenceFrame.bpPerPixel;
+          const chromosomeLengthBP = chromosome.bpLength - chromosome.bpStart;
+          const bppThreshold = scaleFactor < 1.0 ? this.minimumBases() / viewport.$viewport.width() : chromosomeLengthBP / viewport.$viewport.width();
+          const centerBP = undefined === centerBPOrUndefined ? referenceFrame.start + referenceFrame.toBP(viewport.$viewport.width() / 2.0) : centerBPOrUndefined;
+          let bpp;
+
+          if (scaleFactor < 1.0) {
+            bpp = Math.max(referenceFrame.bpPerPixel * scaleFactor, bppThreshold);
+          } else {
+            bpp = Math.min(referenceFrame.bpPerPixel * scaleFactor, bppThreshold);
+          }
+
+          const viewportWidthBP = bpp * viewport.$viewport.width();
+          referenceFrame.start = centerBP - viewportWidthBP / 2;
+          referenceFrame.bpPerPixel = bpp;
+          referenceFrame.clamp(viewport.$viewport.width());
+          const viewChanged = start !== referenceFrame.start || bpPerPixel !== referenceFrame.bpPerPixel;
+
+          if (viewChanged) {
+            this.updateViews(viewport.referenceFrame);
+          }
+        }
+      }
+
+      presentSplitScreenMultiLocusPanel(alignment, leftMatePairReferenceFrame) {
+        // account for reduced viewport width as a result of adding right mate pair panel
+        const viewportWidth = this.computeViewportWidth(1 + this.referenceFrameList.length, this.getViewportContainerWidth());
+        adjustReferenceFrame(leftMatePairReferenceFrame, viewportWidth, alignment.start, alignment.lengthOnRef); // create right mate pair reference frame
+
+        const mateChrName = this.genome.getChromosomeName(alignment.mate.chr);
+        const rightMatePairReferenceFrame = createReferenceFrameWithAlignment(this.genome, mateChrName, leftMatePairReferenceFrame.bpPerPixel, viewportWidth, alignment.mate.position, alignment.lengthOnRef); // add right mate panel beside left mate panel
+
+        this.addMultiLocusPanelWithReferenceFrameIndex(rightMatePairReferenceFrame, 1 + this.referenceFrameList.indexOf(leftMatePairReferenceFrame), viewportWidth);
+      }
+
+      selectMultiLocusPanelWithReferenceFrame(referenceFrame) {
+        const removable = this.referenceFrameList.filter(r => referenceFrame !== r);
+        removable.forEach(r => this.removeMultiLocusPanelWithReferenceFrame(r, false));
+        this.resize();
+      }
+
+      removeMultiLocusPanelWithReferenceFrame(referenceFrame, doResize) {
+        for (let trackView of this.trackViews) {
+          trackView.removeViewportForReferenceFrame(referenceFrame);
+        }
+
+        const index = this.referenceFrameList.indexOf(referenceFrame);
+        this.referenceFrameList.splice(index, 1);
+        this.updateUIWithReferenceFrameListChange(this.referenceFrameList);
+
+        if (true === doResize) {
+          this.resize();
+        } else {
+          for (let {
+            viewports,
+            $viewportContainer
+          } of this.trackViews) {
+            updateViewportShims(viewports, $viewportContainer);
+          }
+        }
+      }
+
+      addMultiLocusPanelWithReferenceFrameIndex(referenceFrame, index, viewportWidth) {
+        if (index === this.referenceFrameList.length) {
+          this.referenceFrameList.push(referenceFrame);
+
+          for (let trackView of this.trackViews) {
+            const viewport = createViewport(trackView, this.referenceFrameList, index, viewportWidth);
+            trackView.viewports.push(viewport);
+            const $detached = viewport.$viewport.detach();
+            $detached.insertAfter(trackView.viewports[index - 1].$viewport);
+          }
+        } else {
+          this.referenceFrameList.splice(index, 0, referenceFrame);
+
+          for (let trackView of this.trackViews) {
+            const viewport = createViewport(trackView, this.referenceFrameList, index, viewportWidth);
+            trackView.viewports.splice(index, 0, viewport);
+            const $detached = viewport.$viewport.detach();
+            $detached.insertAfter(trackView.viewports[index - 1].$viewport);
+          }
+        }
+
+        for (let trackView of this.trackViews) {
+          trackView.updateViewportForMultiLocus();
+        }
+
+        if (this.rulerTrack) {
+          this.rulerTrack.updateLocusLabel();
+        }
+
+        this.updateUIWithReferenceFrameListChange(this.referenceFrameList);
+        this.resize();
+      }
+
+      getViewportWithGUID(guid) {
+        let result = undefined;
+
+        for (let trackView of this.trackViews) {
+          for (let viewport of trackView.viewports) {
+            if (guid === viewport.guid) {
+              result = viewport;
+            }
+          }
+        }
+
+        return result;
+      }
+
+      /**
+       * @deprecated  This is a deprecated method with no known usages.  To be removed in a future release.
+       */
+      async goto(chr, start, end) {
+        return this.search(chr + ":" + start + "-" + end);
+      }
+
+      async search(string, init) {
+        const locusObjects = await search(this, string);
+
+        if (locusObjects && (await locusObjects).length > 0) {
+          const referenceFrameList = createReferenceFrameList(this, locusObjects);
+          this.referenceFrameList = referenceFrameList;
+          emptyViewportContainers(this.trackViews);
+
+          for (let trackView of this.trackViews) {
+            trackView.populateViewportContainer(this, referenceFrameList);
+          }
+
+          this.updateUIWithReferenceFrameListChange(referenceFrameList);
+
+          if (!init) {
+            this.updateViews();
+          }
+
+          return referenceFrameList;
+        } else {
+          throw new Error(`Unrecognized locus ${string}`);
+        }
+      }
+
+      async loadSampleInformation(url) {
+        var name = url;
+
+        if (url instanceof File) {
+          name = url.name;
+        }
+
+        var ext = name.substr(name.lastIndexOf('.') + 1);
+
+        if (ext === 'fam') {
+          this.sampleInformation = await loadPlinkFile(url);
+        }
+      }
+
+      // EVENTS
+      on(eventName, fn) {
+        if (!this.eventHandlers[eventName]) {
+          this.eventHandlers[eventName] = [];
+        }
+
+        this.eventHandlers[eventName].push(fn);
+      }
+
+      /**
+       * @deprecated use off()
+       * @param eventName
+       * @param fn
+       */
+      un(eventName, fn) {
+        if (!this.eventHandlers[eventName]) {
+          return;
+        }
+
+        var callbackIndex = this.eventHandlers[eventName].indexOf(fn);
+
+        if (callbackIndex !== -1) {
+          this.eventHandlers[eventName].splice(callbackIndex, 1);
+        }
+      }
+
+      off(eventName, fn) {
+        if (!eventName) {
+          this.eventHandlers = {}; // Remove all event handlers
+        } else if (!fn) {
+          this.eventHandlers[eventName] = []; // Remove all eventhandlers matching name
+        } else {
+          // Remove specific event handler
+          const callbackIndex = this.eventHandlers[eventName].indexOf(fn);
+
+          if (callbackIndex !== -1) {
+            this.eventHandlers[eventName].splice(callbackIndex, 1);
+          }
+        }
+      }
+
+      fireEvent(eventName, args, thisObj) {
+        const handlers = this.eventHandlers[eventName];
+
+        if (undefined === handlers || handlers.length === 0) {
+          return undefined;
+        }
+
+        const scope = thisObj || window;
+        const results = handlers.map(function (event) {
+          return event.apply(scope, args);
+        });
+        return results[0];
+      }
+
+      dispose() {
+        $(window).off(this.namespace);
+        $(document).off(this.namespace);
+        this.eventHandlers = undefined;
+        this.trackViews.forEach(function (tv) {
+          tv.dispose();
+        });
+      }
+
+      toJSON() {
+        const json = {
+          "version": version()
+        };
+
+        if (this.showSampleNames !== undefined) {
+          json['showSampleNames'] = this.showSampleNames;
+        }
+
+        if (this.sampleNameViewportWidth !== defaultSampleNameViewportWidth) {
+          json['sampleNameViewportWidth'] = this.sampleNameViewportWidth;
+        }
+
+        json["reference"] = this.genome.toJSON();
+
+        if (isFilePath(json.reference.fastaURL)) {
+          throw new Error(`Error. Sessions cannot include local file references ${json.reference.fastaURL.name}.`);
+        } else if (isFilePath(json.reference.indexURL)) {
+          throw new Error(`Error. Sessions cannot include local file references ${json.reference.indexURL.name}.`);
+        } // Build locus array (multi-locus view).  Use the first track to extract the loci, any track could be used.
+
+
+        const locus = [];
+        const gtexSelections = {};
+        let anyTrackView = this.trackViews[0];
+
+        for (let viewport of anyTrackView.viewports) {
+          const referenceFrame = viewport.referenceFrame;
+          const pixelWidth = viewport.$viewport[0].clientWidth;
+          const locusString = referenceFrame.presentLocus(pixelWidth);
+          locus.push(locusString);
+
+          if (referenceFrame.selection) {
+            const selection = {
+              gene: referenceFrame.selection.gene,
+              snp: referenceFrame.selection.snp
+            };
+            gtexSelections[locusString] = selection;
+          }
+        }
+
+        json["locus"] = locus.length === 1 ? locus[0] : locus;
+        const gtexKeys = Object.getOwnPropertyNames(gtexSelections);
+
+        if (gtexKeys.length > 0) {
+          json["gtexSelections"] = gtexSelections;
+        }
+
+        const trackJson = [];
+        const errors = [];
+
+        for (let {
+          track
+        } of this.trackViews) {
+          try {
+            let config;
+
+            if (typeof track.getState === "function") {
+              config = track.getState();
+            } else {
+              config = track.config;
+            }
+
+            if (config) {
+              // null backpointer to browser
+              if (config.browser) {
+                delete config.browser;
+              }
+
+              config.order = track.order; //order++;
+
+              trackJson.push(config);
+            }
+          } catch (e) {
+            errors.push(e);
+          }
+        }
+
+        if (errors.length > 0) {
+          let n = 1;
+          let message = 'Errors encountered saving session:';
+
+          for (let e of errors) {
+            message += ` (${n++}) ${e.toString()}`;
+          }
+
+          throw Error(message);
+        } // TODO: Remove this code and thrown error. This error is caught in track.getState()
+
+
+        const locaTrackFiles = trackJson.filter(track => {
+          track.url && isFilePath(track.url);
+        });
+
+        if (locaTrackFiles.length > 0) {
+          throw new Error(`Error. Sessions cannot be saved with local file references.`);
+        }
+
+        json["tracks"] = trackJson;
+        return json; // This is an object, not a json string
+      }
+
+      compressedSession() {
+        const json = JSON.stringify(this.toJSON());
+        return compressString(json);
+      }
+
+      sessionURL() {
+        const path = window.location.href.slice();
+        const idx = path.indexOf("?");
+        const surl = (idx > 0 ? path.substring(0, idx) : path) + "?sessionURL=blob:" + this.compressedSession();
+        return surl;
+      }
+
+      currentLoci() {
+        const loci = [];
+        const anyTrackView = this.trackViews[0];
+
+        for (let viewport of anyTrackView.viewports) {
+          const referenceFrame = viewport.referenceFrame;
+          const pixelWidth = viewport.$viewport[0].clientWidth;
+          const locusString = referenceFrame.presentLocus(pixelWidth);
+          loci.push(locusString);
+        }
+
+        return loci;
+      }
+      /**
+       * Record a mouse click on a specific viewport.   This might be the start of a drag operation.   Dragging
+       * (panning) is handled here so that the mouse can move out of a specific viewport (e.g. stray into another
+       * track) without halting the drag.
+       *
+       * @param e
+       * @param viewport
+       */
+
+
+      mouseDownOnViewport(e, viewport) {
+        var coords;
+        coords = pageCoordinates$1(e);
+        this.vpMouseDown = {
+          viewport: viewport,
+          lastMouseX: coords.x,
+          mouseDownX: coords.x,
+          lastMouseY: coords.y,
+          mouseDownY: coords.y,
+          referenceFrame: viewport.referenceFrame
+        };
+      }
+
+      cancelTrackPan() {
+        const dragObject = this.dragObject;
+        this.dragObject = undefined;
+        this.isScrolling = false;
+        this.vpMouseDown = undefined;
+
+        if (dragObject && dragObject.viewport.referenceFrame.start !== dragObject.start) {
+          this.updateViews();
+          this.fireEvent('trackdragend');
+        }
+      }
+
+      startTrackDrag(trackView) {
+        this.dragTrack = trackView;
+      }
+
+      updateTrackDrag(dragDestination) {
+        if (dragDestination && this.dragTrack) {
+          const dragged = this.dragTrack;
+          const indexDestination = this.trackViews.indexOf(dragDestination);
+          const indexDragged = this.trackViews.indexOf(dragged);
+          const trackViews = this.trackViews;
+          trackViews[indexDestination] = dragged;
+          trackViews[indexDragged] = dragDestination;
+          const newOrder = this.trackViews[indexDestination].track.order;
+          this.trackViews[indexDragged].track.order = newOrder;
+          const nTracks = trackViews.length;
+          let lastOrder = newOrder;
+
+          if (indexDestination < indexDragged) {
+            // Displace tracks below
+            for (let i = indexDestination + 1; i < nTracks; i++) {
+              const track = trackViews[i].track;
+
+              if (track.order <= lastOrder) {
+                track.order = Math.min(Number.MAX_SAFE_INTEGER, lastOrder + 1);
+                lastOrder = track.order;
+              } else {
+                break;
+              }
+            }
+          } else {
+            // Displace tracks above.  First track (index 0) is "ruler"
+            for (let i = indexDestination - 1; i > 0; i--) {
+              const track = trackViews[i].track;
+
+              if (track.order >= lastOrder) {
+                track.order = Math.max(-Number.MAX_SAFE_INTEGER, lastOrder - 1);
+                lastOrder = track.order;
+              } else {
+                break;
+              }
+            }
+          }
+
+          this.reorderTracks();
+        }
+      }
+
+      endTrackDrag() {
+        if (this.dragTrack) {
+          this.dragTrack.$trackDragScrim.hide();
+          this.dragTrack = undefined;
+          this.fireEvent('trackorderchanged', [this.getTrackOrder()]);
+        } else {
+          this.dragTrack = undefined;
+        }
+      }
+      /**
+       * Mouse handlers to support drag (pan)
+       */
+
+
+      addMouseHandlers() {
+        var self = this;
+        $(window).on('resize' + this.namespace, () => {
+          this.resize();
+        });
+        $(this.root).on('mouseup', mouseUpOrLeave);
+        $(this.root).on('mouseleave', mouseUpOrLeave);
+        $(this.trackContainer).on('mousemove', handleMouseMove);
+        $(this.trackContainer).on('touchmove', handleMouseMove);
+        $(this.trackContainer).on('mouseleave', mouseUpOrLeave);
+        $(this.trackContainer).on('mouseup', mouseUpOrLeave);
+        $(this.trackContainer).on('touchend', mouseUpOrLeave);
+
+        function handleMouseMove(e) {
+          var coords, viewport, viewportWidth, referenceFrame;
+          e.preventDefault();
+
+          if (self.loadInProgress()) {
+            return;
+          }
+
+          coords = pageCoordinates$1(e);
+
+          if (self.vpMouseDown) {
+            // Determine direction,  true == horizontal
+            const horizontal = Math.abs(coords.x - self.vpMouseDown.mouseDownX) > Math.abs(coords.y - self.vpMouseDown.mouseDownY);
+            viewport = self.vpMouseDown.viewport;
+            viewportWidth = viewport.$viewport.width();
+            referenceFrame = viewport.referenceFrame;
+
+            if (!self.dragObject && !self.isScrolling) {
+              if (horizontal) {
+                if (self.vpMouseDown.mouseDownX && Math.abs(coords.x - self.vpMouseDown.mouseDownX) > self.constants.dragThreshold) {
+                  self.dragObject = {
+                    viewport: viewport,
+                    start: referenceFrame.start
+                  };
+                }
+              } else {
+                if (self.vpMouseDown.mouseDownY && Math.abs(coords.y - self.vpMouseDown.mouseDownY) > self.constants.scrollThreshold) {
+                  self.isScrolling = true;
+                  const trackView = viewport.trackView;
+                  const viewportContainerHeight = trackView.$viewportContainer.height();
+                  const contentHeight = maxViewportContentHeight(trackView.viewports);
+                  self.vpMouseDown.r = viewportContainerHeight / contentHeight;
+                }
+              }
+            }
+
+            if (self.dragObject) {
+              const viewChanged = referenceFrame.shiftPixels(self.vpMouseDown.lastMouseX - coords.x, viewportWidth);
+
+              if (viewChanged) {
+                if (self.referenceFrameList.length > 1) {
+                  self.updateLocusSearchWidget(self.referenceFrameList);
+                } else {
+                  self.updateLocusSearchWidget([self.vpMouseDown.referenceFrame]);
+                }
+
+                self.updateViews();
+              }
+
+              self.fireEvent('trackdrag');
+            }
+
+            if (self.isScrolling) {
+              const delta = self.vpMouseDown.r * (self.vpMouseDown.lastMouseY - coords.y);
+              self.vpMouseDown.viewport.trackView.scrollBy(delta);
+            }
+
+            self.vpMouseDown.lastMouseX = coords.x;
+            self.vpMouseDown.lastMouseY = coords.y;
+          }
+        }
+
+        function mouseUpOrLeave(e) {
+          self.cancelTrackPan();
+          self.endTrackDrag();
+        }
+      }
+
+      async getDriveFileInfo(googleDriveURL) {
+        const id = getGoogleDriveFileID(googleDriveURL);
+        const endPoint = "https://www.googleapis.com/drive/v3/files/" + id + "?supportsTeamDrives=true";
+        return igvxhr.loadJson(endPoint, buildOptions({}));
+      }
+
+      static uncompressSession(url) {
+        let bytes;
+
+        if (url.indexOf('/gzip;base64') > 0) {
+          //Proper dataURI
+          bytes = decodeDataURI$1(url);
+          let json = '';
+
+          for (let b of bytes) {
+            json += String.fromCharCode(b);
+          }
+
+          return json;
+        } else {
+          let enc = url.substring(5);
+          return uncompressString(enc);
+        }
+      }
+
+    }
+
+    function toggleTrackLabels(trackViews, isVisible) {
+      for (let trackView of trackViews) {
+        for (let viewport of trackView.viewports) {
+          if (viewport.$trackLabel) {
+            if (0 === trackView.viewports.indexOf(viewport) && true === isVisible) {
+              viewport.$trackLabel.show();
+            } else {
+              viewport.$trackLabel.hide();
+            }
+          }
+        }
+      }
+    }
+
+    function logo() {
+      return $('<svg width="690px" height="324px" viewBox="0 0 690 324" version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">' + '<title>IGV</title>' + '<g id="Page-1" stroke="none" stroke-width="1" fill="none" fill-rule="evenodd">' + '<g id="IGV" fill="#666666">' + '<polygon id="Path" points="379.54574 8.00169252 455.581247 8.00169252 515.564813 188.87244 532.884012 253.529506 537.108207 253.529506 554.849825 188.87244 614.833392 8.00169252 689.60164 8.00169252 582.729511 320.722144 486.840288 320.722144"></polygon>' + '<path d="M261.482414,323.793286 C207.975678,323.793286 168.339046,310.552102 142.571329,284.069337 C116.803612,257.586572 103.919946,217.158702 103.919946,162.784513 C103.919946,108.410325 117.437235,67.8415913 144.472217,41.0770945 C171.507199,14.3125977 212.903894,0.930550071 268.663545,0.930550071 C283.025879,0.930550071 298.232828,1.84616386 314.284849,3.6774189 C330.33687,5.50867394 344.839793,7.97378798 357.794056,11.072835 L357.794056,68.968378 C339.48912,65.869331 323.578145,63.5450806 310.060654,61.9955571 C296.543163,60.4460336 284.574731,59.6712835 274.154998,59.6712835 C255.850062,59.6712835 240.502308,61.4320792 228.111274,64.9537236 C215.720241,68.4753679 205.793482,74.2507779 198.330701,82.2801269 C190.867919,90.309476 185.587729,100.87425 182.48997,113.974767 C179.392212,127.075284 177.843356,143.345037 177.843356,162.784513 C177.843356,181.942258 179.251407,198.000716 182.067551,210.960367 C184.883695,223.920018 189.671068,234.41436 196.429813,242.443709 C203.188559,250.473058 212.059279,256.178037 223.042241,259.558815 C234.025202,262.939594 247.683295,264.629958 264.01693,264.629958 C268.241146,264.629958 273.098922,264.489094 278.590403,264.207362 C284.081883,263.925631 289.643684,263.50304 295.275972,262.939577 L295.275972,159.826347 L361.595831,159.826347 L361.595831,308.579859 C344.698967,313.087564 327.239137,316.750019 309.215815,319.567334 C291.192494,322.38465 275.281519,323.793286 261.482414,323.793286 L261.482414,323.793286 L261.482414,323.793286 Z" id="Path"></path>;' + '<polygon id="Path" points="0.81355666 5.00169252 73.0472883 5.00169252 73.0472883 317.722144 0.81355666 317.722144"></polygon>' + '</g> </g> </svg>');
+    }
+
+    /*
+     * The MIT License (MIT)
+     *
+     * Copyright (c) 2014 Broad Institute
+     *
+     * Permission is hereby granted, free of charge, to any person obtaining a copy
+     * of this software and associated documentation files (the "Software"), to deal
+     * in the Software without restriction, including without limitation the rights
+     * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+     * copies of the Software, and to permit persons to whom the Software is
+     * furnished to do so, subject to the following conditions:
+     *
+     * The above copyright notice and this permission notice shall be included in
+     * all copies or substantial portions of the Software.
+     *
+     *
+     * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+     * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+     * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+     * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+     * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+     * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+     * THE SOFTWARE.
+     */
+    let allBrowsers = [];
+    /**
+     * Create an igv.browser instance.  This object defines the public API for interacting with the genome browser.
+     *
+     * @param parentDiv - DOM tree root
+     * @param config - configuration options.
+     *
+     */
+
+    async function createBrowser(parentDiv, config) {
+      if (undefined === config) config = {}; // Initialize pre-defined genomes.  The genome list is shared among all browser instances
+
+      if (!GenomeUtils.KNOWN_GENOMES) {
+        await GenomeUtils.initializeGenomes(config);
+      }
+
+      setDefaults(config);
+
+      if (config.queryParametersSupported !== false) {
+        extractQuery(config);
+      }
+
+      if (config.apiKey) {
+        igvxhr.setApiKey(config.apiKey);
+      }
+
+      if (config.oauthToken) {
+        oauth.setToken(config.oauthToken);
+      }
+
+      if (config.clientId && !isInitialized()) {
+        await init$1({
+          clientId: config.clientId,
+          apiKey: config.apiKey,
+          scope: 'https://www.googleapis.com/auth/userinfo.profile'
+        });
+      } // Create browser
+
+
+      const browser = new Browser(config, parentDiv);
+      allBrowsers.push(browser); // Load initial session
+
+      if (config.sessionURL) {
+        await browser.loadSession({
+          url: config.sessionURL
+        });
+      } else {
+        await browser.loadSessionObject(config);
+      } // Session dependent browser settings (do not set until session is loaded)
+
+
+      const isWGV = browser.isMultiLocusWholeGenomeView() || GenomeUtils.isWholeGenomeView(browser.referenceFrameList[0].chr);
+
+      if (browser.isMultiLocusMode() || isWGV) {
+        browser.centerGuide.forcedHide();
+      } else {
+        browser.centerGuide.forcedShow();
+      }
+
+      browser.navbarManager.navbarDidResize(browser.$navigation.width(), isWGV);
+      return browser;
+    }
+
+    function removeBrowser(browser) {
+      browser.dispose();
+      browser.$root.remove();
+      allBrowsers = allBrowsers.filter(item => item !== browser);
+    }
+
+    function removeAllBrowsers() {
+      for (let browser of allBrowsers) {
+        browser.dispose();
+        browser.$root.remove();
+      }
+
+      allBrowsers = [];
+    }
+    /**
+     * This function provided so clients can inform igv of a visibility change, typically when an igv instance is
+     * made visible from a tab, accordion, or similar widget.
+     */
+
+
+    async function visibilityChange() {
+      for (let browser of allBrowsers) {
+        await browser.visibilityChange();
+      }
+    }
+
+    function setDefaults(config) {
+      if (undefined === config.promisified) {
+        config.promisified = false;
+      }
+
+      if (undefined === config.minimumBases) {
+        config.minimumBases = 40;
+      }
+
+      if (undefined === config.showIdeogram) {
+        config.showIdeogram = true;
+      }
+
+      if (undefined === config.showTrackLabelButton) {
+        config.showTrackLabelButton = true;
+      }
+
+      if (undefined === config.showTrackLabels) {
+        config.showTrackLabels = true;
+      }
+
+      if (undefined === config.showCursorTrackingGuideButton) {
+        config.showCursorTrackingGuideButton = true;
+      }
+
+      if (undefined === config.showCursorTrackingGuide) {
+        config.showCursorTrackingGuide = false;
+      }
+
+      if (undefined === config.showCenterGuideButton) {
+        config.showCenterGuideButton = true;
+      }
+
+      if (undefined === config.showCenterGuide) {
+        config.showCenterGuide = false;
+      }
+
+      if (undefined === config.showSampleNames) {
+        config.showSampleNames = false;
+      }
+
+      if (undefined === config.showSVGButton) {
+        config.showSVGButton = true;
+      }
+
+      if (config.showControls === undefined) {
+        config.showControls = true;
+      }
+
+      if (config.showNavigation === undefined) {
+        config.showNavigation = true;
+      }
+
+      if (config.showRuler === undefined) {
+        config.showRuler = true;
+      }
+
+      if (config.flanking === undefined) {
+        config.flanking = 1000;
+      }
+
+      if (config.pairsSupported === undefined) {
+        config.pairsSupported = true;
+      }
+
+      if (!config.tracks) {
+        config.tracks = [];
+      }
+    }
+
+    function extractQuery(config) {
+      var i1, i2, i, j, s, query, tokens, uri, key, value;
+      uri = window.location.href;
+      query = {};
+      i1 = uri.indexOf("?");
+      i2 = uri.lastIndexOf("#");
+      let files;
+      let indexURLs;
+
+      if (i1 >= 0) {
+        if (i2 < 0) i2 = uri.length;
+
+        for (i = i1 + 1; i < i2;) {
+          j = uri.indexOf("&", i);
+          if (j < 0) j = i2;
+          s = uri.substring(i, j);
+          tokens = s.split("=", 2);
+
+          if (tokens.length === 2) {
+            key = tokens[0];
+            value = decodeURIComponent(tokens[1]);
+
+            if ('file' === key) {
+              // IGV desktop style file parameter
+              files = value.split(',');
+            } else if ('index' === key) {
+              // IGV desktop style index parameter
+              indexURLs = value.split(',');
+            } else {
+              config[key] = value;
+            }
+
+            i = j + 1;
+          }
+        }
+      }
+
+      if (files) {
+        if (!config.tracks) config.tracks = [];
+
+        for (let i = 0; i < files.length; i++) {
+          if (files[i].endsWith(".xml") || files[i].endsWith(".json")) {
+            config.sessionURL = files[i];
+            break;
+          }
+
+          const trackConfig = {
+            url: files[i]
+          };
+
+          if (indexURLs && indexURLs.length > i) {
+            trackConfig.indexURL = indexURLs[i];
+          }
+
+          config.tracks.push(trackConfig);
+        }
+      }
+
+      return query;
+    }
+
+    async function createTrack(config, browser) {
+      return await Browser.prototype.createTrack.call(browser, config);
+    }
+
+    function embedCSS() {
+      var css = '.igv-generic-container {\n  position: absolute;\n  top: 0;\n  left: 0;\n  z-index: 2048;\n  background-color: white;\n  cursor: pointer;\n  display: flex;\n  flex-direction: row;\n  flex-wrap: wrap;\n  justify-content: flex-start;\n  align-items: center; }\n  .igv-generic-container div:first-child {\n    cursor: move;\n    display: flex;\n    flex-flow: row;\n    flex-wrap: nowrap;\n    justify-content: flex-end;\n    align-items: center;\n    height: 24px;\n    width: 100%;\n    background-color: #dddddd; }\n    .igv-generic-container div:first-child i {\n      display: block;\n      color: #5f5f5f;\n      cursor: pointer;\n      width: 14px;\n      height: 14px;\n      margin-right: 8px;\n      margin-bottom: 4px; }\n\n.igv-generic-dialog-container {\n  position: absolute;\n  top: 0;\n  left: 0;\n  width: 300px;\n  height: 200px;\n  border-color: #7F7F7F;\n  border-radius: 4px;\n  border-style: solid;\n  border-width: thin;\n  font-family: \"Open Sans\", sans-serif;\n  font-size: medium;\n  font-weight: 400;\n  z-index: 2048;\n  background-color: white;\n  display: flex;\n  flex-flow: column;\n  flex-wrap: nowrap;\n  justify-content: flex-start;\n  align-items: center; }\n  .igv-generic-dialog-container .igv-generic-dialog-header {\n    display: flex;\n    flex-flow: row;\n    flex-wrap: nowrap;\n    justify-content: flex-end;\n    align-items: center;\n    width: 100%;\n    height: 24px;\n    cursor: move;\n    border-top-left-radius: 4px;\n    border-top-right-radius: 4px;\n    border-bottom-color: #7F7F7F;\n    border-bottom-style: solid;\n    border-bottom-width: thin;\n    background-color: #eee; }\n    .igv-generic-dialog-container .igv-generic-dialog-header div {\n      margin-right: 4px;\n      margin-bottom: 2px;\n      height: 12px;\n      width: 12px;\n      color: #7F7F7F; }\n    .igv-generic-dialog-container .igv-generic-dialog-header div:hover {\n      cursor: pointer;\n      color: #444; }\n  .igv-generic-dialog-container .igv-generic-dialog-one-liner {\n    color: #373737;\n    width: 95%;\n    height: 24px;\n    line-height: 24px;\n    text-align: left;\n    margin-top: 8px;\n    padding-left: 8px;\n    overflow-wrap: break-word;\n    background-color: white; }\n  .igv-generic-dialog-container .igv-generic-dialog-label-input {\n    margin-top: 8px;\n    width: 95%;\n    height: 24px;\n    color: #373737;\n    line-height: 24px;\n    padding-left: 8px;\n    background-color: white;\n    display: flex;\n    flex-flow: row;\n    flex-wrap: nowrap;\n    justify-content: flex-start;\n    align-items: center; }\n    .igv-generic-dialog-container .igv-generic-dialog-label-input div {\n      width: 30%;\n      height: 100%;\n      font-size: 16px;\n      text-align: right;\n      padding-right: 8px;\n      background-color: white; }\n    .igv-generic-dialog-container .igv-generic-dialog-label-input input {\n      display: block;\n      height: 100%;\n      width: 100%;\n      padding-left: 4px;\n      font-family: \"Open Sans\", sans-serif;\n      font-weight: 400;\n      color: #373737;\n      text-align: left;\n      outline: none;\n      border-style: solid;\n      border-width: thin;\n      border-color: #7F7F7F;\n      background-color: white; }\n    .igv-generic-dialog-container .igv-generic-dialog-label-input input {\n      width: 50%;\n      font-size: 16px; }\n  .igv-generic-dialog-container .igv-generic-dialog-input {\n    margin-top: 8px;\n    width: calc(100% - 16px);\n    height: 24px;\n    color: #373737;\n    line-height: 24px;\n    display: flex;\n    flex-flow: row;\n    flex-wrap: nowrap;\n    justify-content: space-around;\n    align-items: center; }\n    .igv-generic-dialog-container .igv-generic-dialog-input input {\n      display: block;\n      height: 100%;\n      width: 100%;\n      padding-left: 4px;\n      font-family: \"Open Sans\", sans-serif;\n      font-weight: 400;\n      color: #373737;\n      text-align: left;\n      outline: none;\n      border-style: solid;\n      border-width: thin;\n      border-color: #7F7F7F;\n      background-color: white; }\n    .igv-generic-dialog-container .igv-generic-dialog-input input {\n      font-size: 16px; }\n  .igv-generic-dialog-container .igv-generic-dialog-ok-cancel {\n    width: 100%;\n    height: 28px;\n    display: flex;\n    flex-flow: row;\n    flex-wrap: nowrap;\n    justify-content: space-around;\n    align-items: center; }\n    .igv-generic-dialog-container .igv-generic-dialog-ok-cancel div {\n      margin-top: 32px;\n      color: white;\n      font-family: \"Open Sans\", sans-serif;\n      font-size: 14px;\n      font-weight: 400;\n      width: 75px;\n      height: 28px;\n      line-height: 28px;\n      text-align: center;\n      border-color: transparent;\n      border-style: solid;\n      border-width: thin;\n      border-radius: 2px; }\n    .igv-generic-dialog-container .igv-generic-dialog-ok-cancel div:first-child {\n      margin-left: 32px;\n      margin-right: 0;\n      background-color: #5ea4e0; }\n    .igv-generic-dialog-container .igv-generic-dialog-ok-cancel div:last-child {\n      margin-left: 0;\n      margin-right: 32px;\n      background-color: #c4c4c4; }\n    .igv-generic-dialog-container .igv-generic-dialog-ok-cancel div:first-child:hover {\n      cursor: pointer;\n      background-color: #3b5c7f; }\n    .igv-generic-dialog-container .igv-generic-dialog-ok-cancel div:last-child:hover {\n      cursor: pointer;\n      background-color: #7f7f7f; }\n  .igv-generic-dialog-container .igv-generic-dialog-ok {\n    width: 100%;\n    height: 36px;\n    margin-top: 32px;\n    display: flex;\n    flex-flow: row;\n    flex-wrap: nowrap;\n    justify-content: space-around;\n    align-items: center; }\n    .igv-generic-dialog-container .igv-generic-dialog-ok div {\n      width: 98px;\n      height: 36px;\n      line-height: 36px;\n      text-align: center;\n      color: white;\n      font-family: \"Open Sans\", sans-serif;\n      font-size: medium;\n      font-weight: 400;\n      border-color: white;\n      border-style: solid;\n      border-width: thin;\n      border-radius: 4px;\n      background-color: #2B81AF; }\n    .igv-generic-dialog-container .igv-generic-dialog-ok div:hover {\n      cursor: pointer;\n      background-color: #25597f; }\n\n.igv-menu-popup {\n  position: absolute;\n  top: 0;\n  left: 0;\n  min-width: 132px;\n  z-index: 4096;\n  cursor: pointer;\n  font-family: \"Open Sans\", sans-serif;\n  font-size: small;\n  font-weight: 400;\n  color: #4b4b4b;\n  background: white;\n  border-radius: 4px;\n  border-color: #7F7F7F;\n  border-style: solid;\n  border-width: thin;\n  display: flex;\n  flex-flow: column;\n  flex-wrap: nowrap;\n  justify-content: flex-start;\n  align-items: flex-end;\n  text-align: left; }\n  .igv-menu-popup > div:not(:first-child) {\n    width: 100%; }\n    .igv-menu-popup > div:not(:first-child) > div {\n      background: white; }\n    .igv-menu-popup > div:not(:first-child) > div.context-menu {\n      padding-left: 4px;\n      padding-right: 4px; }\n    .igv-menu-popup > div:not(:first-child) > div:last-child {\n      border-bottom-left-radius: 4px;\n      border-bottom-right-radius: 4px;\n      border-bottom-color: transparent;\n      border-bottom-style: solid;\n      border-bottom-width: thin; }\n    .igv-menu-popup > div:not(:first-child) > div:hover {\n      background: #efefef; }\n\n.igv-menu-popup-shim {\n  padding-left: 8px;\n  padding-right: 8px; }\n\n.igv-menu-popup-header {\n  position: relative;\n  width: 100%;\n  height: 24px;\n  cursor: move;\n  border-top-color: transparent;\n  border-top-left-radius: 4px;\n  border-top-right-radius: 4px;\n  border-bottom-color: #7F7F7F;\n  border-bottom-style: solid;\n  border-bottom-width: thin;\n  background-color: #eee;\n  display: flex;\n  flex-flow: row;\n  flex-wrap: nowrap;\n  justify-content: flex-end;\n  align-items: center; }\n  .igv-menu-popup-header div {\n    margin-right: 4px;\n    height: 12px;\n    width: 12px;\n    color: #7F7F7F; }\n  .igv-menu-popup-header div:hover {\n    cursor: pointer;\n    color: #444; }\n\n.igv-menu-popup-check-container {\n  display: flex;\n  flex-flow: row;\n  flex-wrap: nowrap;\n  justify-content: flex-start;\n  align-items: center;\n  width: 100%;\n  height: 20px;\n  background-color: transparent; }\n  .igv-menu-popup-check-container div {\n    padding-top: 2px;\n    padding-left: 8px; }\n  .igv-menu-popup-check-container div:first-child {\n    position: relative;\n    width: 12px;\n    height: 12px; }\n    .igv-menu-popup-check-container div:first-child svg {\n      position: absolute;\n      width: 12px;\n      height: 12px; }\n\n.igv-user-feedback {\n  position: fixed;\n  top: 50%;\n  left: 50%;\n  transform: translate(-50%, -50%);\n  width: 512px;\n  height: 360px;\n  z-index: 2048;\n  background-color: white;\n  border-color: #a2a2a2;\n  border-style: solid;\n  border-width: thin;\n  font-family: \"Open Sans\", sans-serif;\n  font-size: medium;\n  font-weight: 400;\n  color: #444;\n  display: flex;\n  flex-direction: column;\n  flex-wrap: nowrap;\n  justify-content: flex-start;\n  align-items: center; }\n  .igv-user-feedback div:first-child {\n    position: relative;\n    height: 24px;\n    width: 100%;\n    background-color: white;\n    border-bottom-color: #a2a2a2;\n    border-bottom-style: solid;\n    border-bottom-width: thin; }\n    .igv-user-feedback div:first-child div {\n      position: absolute;\n      top: 2px;\n      width: 16px;\n      height: 16px;\n      background-color: transparent; }\n    .igv-user-feedback div:first-child div:first-child {\n      left: 8px; }\n    .igv-user-feedback div:first-child div:last-child {\n      cursor: pointer;\n      right: 8px; }\n  .igv-user-feedback div:last-child {\n    width: 100%;\n    height: calc(100% - 24px);\n    border-width: 0; }\n    .igv-user-feedback div:last-child div {\n      width: auto;\n      height: auto;\n      margin: 8px; }\n\n.igv-root {\n  position: relative;\n  padding-top: 4px;\n  margin-left: 10px;\n  margin-right: 10px;\n  display: flex;\n  flex-flow: column;\n  flex-wrap: nowrap;\n  justify-content: flex-start;\n  align-items: stretch; }\n  .igv-root .igv-navbar {\n    display: flex;\n    flex-flow: row;\n    flex-wrap: nowrap;\n    justify-content: space-between;\n    align-items: center;\n    color: #444;\n    font-size: 12px;\n    font-family: \"Open Sans\", sans-serif;\n    font-weight: 400;\n    line-height: 32px;\n    padding-left: 8px;\n    padding-right: 8px;\n    margin-top: 2px;\n    margin-bottom: 4px;\n    height: 32px;\n    border-style: solid;\n    border-radius: 3px;\n    border-width: thin;\n    border-color: #bfbfbf;\n    background-color: #f3f3f3; }\n    .igv-root .igv-navbar .igv-navbar-left-container {\n      display: flex;\n      flex-flow: row;\n      flex-wrap: nowrap;\n      justify-content: space-between;\n      align-items: center;\n      height: 32px;\n      line-height: 32px; }\n      .igv-root .igv-navbar .igv-navbar-left-container .igv-logo {\n        width: 34px;\n        height: 32px;\n        margin-right: 8px; }\n      .igv-root .igv-navbar .igv-navbar-left-container .igv-current-genome {\n        height: 32px;\n        margin-left: 4px;\n        margin-right: 4px;\n        user-select: none;\n        line-height: 32px;\n        vertical-align: middle;\n        text-align: center; }\n      .igv-root .igv-navbar .igv-navbar-left-container .igv-navbar-genomic-location {\n        display: flex;\n        flex-flow: row;\n        flex-wrap: nowrap;\n        justify-content: space-between;\n        align-items: center;\n        height: 100%; }\n        .igv-root .igv-navbar .igv-navbar-left-container .igv-navbar-genomic-location .igv-chromosome-select-widget-container {\n          display: flex;\n          flex-flow: column;\n          flex-wrap: nowrap;\n          justify-content: space-around;\n          align-items: center;\n          height: 100%;\n          width: 125px;\n          margin-right: 4px; }\n          .igv-root .igv-navbar .igv-navbar-left-container .igv-navbar-genomic-location .igv-chromosome-select-widget-container select {\n            display: block;\n            cursor: pointer;\n            width: 100px;\n            height: 75%;\n            outline: none;\n            font-size: 12px;\n            font-family: \"Open Sans\", sans-serif;\n            font-weight: 400; }\n        .igv-root .igv-navbar .igv-navbar-left-container .igv-navbar-genomic-location .igv-locus-size-group {\n          display: flex;\n          flex-flow: row;\n          flex-wrap: nowrap;\n          justify-content: space-between;\n          align-items: center;\n          margin-left: 8px;\n          height: 22px; }\n          .igv-root .igv-navbar .igv-navbar-left-container .igv-navbar-genomic-location .igv-locus-size-group .igv-search-container {\n            display: flex;\n            flex-flow: row;\n            flex-wrap: nowrap;\n            justify-content: flex-start;\n            align-items: center;\n            width: 200px;\n            height: 22px;\n            line-height: 22px; }\n            .igv-root .igv-navbar .igv-navbar-left-container .igv-navbar-genomic-location .igv-locus-size-group .igv-search-container input.igv-search-input {\n              cursor: text;\n              width: 85%;\n              height: 22px;\n              line-height: 22px;\n              font-size: 12px;\n              font-family: \"Open Sans\", sans-serif;\n              font-weight: 400;\n              text-align: left;\n              padding-left: 8px;\n              margin-right: 8px;\n              outline: none;\n              border-style: solid;\n              border-radius: 3px;\n              border-width: thin;\n              border-color: #bfbfbf;\n              background-color: white; }\n            .igv-root .igv-navbar .igv-navbar-left-container .igv-navbar-genomic-location .igv-locus-size-group .igv-search-container .igv-search-icon-container {\n              cursor: pointer;\n              height: 16px;\n              width: 16px; }\n          .igv-root .igv-navbar .igv-navbar-left-container .igv-navbar-genomic-location .igv-locus-size-group .igv-windowsize-panel-container {\n            margin-left: 4px;\n            user-select: none; }\n    .igv-root .igv-navbar .igv-navbar-right-container {\n      display: flex;\n      flex-flow: row;\n      flex-wrap: nowrap;\n      justify-content: space-between;\n      align-items: center;\n      height: 32px;\n      line-height: 32px; }\n      .igv-root .igv-navbar .igv-navbar-right-container .igv-navbar-toggle-button-container {\n        display: flex;\n        flex-flow: row;\n        flex-wrap: nowrap;\n        justify-content: space-between;\n        align-items: center;\n        height: 100%; }\n        .igv-root .igv-navbar .igv-navbar-right-container .igv-navbar-toggle-button-container div {\n          margin-left: 0;\n          margin-right: 4px; }\n        .igv-root .igv-navbar .igv-navbar-right-container .igv-navbar-toggle-button-container div:last-child {\n          margin-left: 0;\n          margin-right: 0; }\n      .igv-root .igv-navbar .igv-navbar-right-container .igv-navbar-toggle-button-container-750 {\n        display: none; }\n      .igv-root .igv-navbar .igv-navbar-right-container .igv-zoom-widget {\n        color: #737373;\n        font-size: 18px;\n        height: 32px;\n        line-height: 32px;\n        margin-left: 8px;\n        user-select: none;\n        display: flex;\n        flex-flow: row;\n        flex-wrap: nowrap;\n        justify-content: flex-end;\n        align-items: center; }\n        .igv-root .igv-navbar .igv-navbar-right-container .igv-zoom-widget div {\n          cursor: pointer;\n          margin-left: unset;\n          margin-right: unset; }\n        .igv-root .igv-navbar .igv-navbar-right-container .igv-zoom-widget div:first-child {\n          height: 24px;\n          width: 24px;\n          margin-left: unset;\n          margin-right: 8px; }\n        .igv-root .igv-navbar .igv-navbar-right-container .igv-zoom-widget div:last-child {\n          height: 24px;\n          width: 24px;\n          margin-left: 8px;\n          margin-right: unset; }\n        .igv-root .igv-navbar .igv-navbar-right-container .igv-zoom-widget div:nth-child(even) {\n          display: block;\n          height: fit-content; }\n        .igv-root .igv-navbar .igv-navbar-right-container .igv-zoom-widget input {\n          display: block;\n          width: 125px; }\n        .igv-root .igv-navbar .igv-navbar-right-container .igv-zoom-widget svg {\n          display: block; }\n      .igv-root .igv-navbar .igv-navbar-right-container .igv-zoom-widget-900 {\n        color: #737373;\n        font-size: 18px;\n        height: 32px;\n        line-height: 32px;\n        margin-left: 8px;\n        user-select: none;\n        display: flex;\n        flex-flow: row;\n        flex-wrap: nowrap;\n        justify-content: flex-end;\n        align-items: center; }\n        .igv-root .igv-navbar .igv-navbar-right-container .igv-zoom-widget-900 div {\n          cursor: pointer;\n          margin-left: unset;\n          margin-right: unset; }\n        .igv-root .igv-navbar .igv-navbar-right-container .igv-zoom-widget-900 div:first-child {\n          height: 24px;\n          width: 24px;\n          margin-left: unset;\n          margin-right: 8px; }\n        .igv-root .igv-navbar .igv-navbar-right-container .igv-zoom-widget-900 div:last-child {\n          height: 24px;\n          width: 24px;\n          margin-left: 8px;\n          margin-right: unset; }\n        .igv-root .igv-navbar .igv-navbar-right-container .igv-zoom-widget-900 div:nth-child(even) {\n          width: 0;\n          height: 0;\n          display: none; }\n        .igv-root .igv-navbar .igv-navbar-right-container .igv-zoom-widget-900 input {\n          width: 0;\n          height: 0;\n          display: none; }\n        .igv-root .igv-navbar .igv-navbar-right-container .igv-zoom-widget-900 svg {\n          display: block; }\n      .igv-root .igv-navbar .igv-navbar-right-container .igv-zoom-widget-hidden {\n        display: none; }\n  .igv-root .igv-track-container {\n    position: relative; }\n    .igv-root .igv-track-container .igv-track {\n      position: relative;\n      width: 100%;\n      margin-top: 4px;\n      display: flex;\n      flex-flow: row;\n      flex-wrap: nowrap;\n      justify-content: flex-start;\n      align-items: stretch; }\n      .igv-root .igv-track-container .igv-track .igv-viewport-container {\n        position: relative;\n        display: flex;\n        flex-flow: row;\n        flex-wrap: nowrap;\n        justify-content: flex-start;\n        align-items: stretch;\n        width: calc(100% - 62px);\n        height: 100%; }\n        .igv-root .igv-track-container .igv-track .igv-viewport-container .igv-axis-container {\n          position: relative;\n          width: 50px;\n          height: 100%; }\n        .igv-root .igv-track-container .igv-track .igv-viewport-container .igv-viewport {\n          position: relative;\n          height: 100%;\n          overflow-x: hidden;\n          overflow-y: hidden;\n          background-color: white; }\n          .igv-root .igv-track-container .igv-track .igv-viewport-container .igv-viewport .igv-viewport-content {\n            position: relative;\n            width: 100%; }\n        .igv-root .igv-track-container .igv-track .igv-viewport-container .igv-viewport-multi-locus-gap-shim {\n          height: 100%;\n          width: 1px;\n          margin-left: 2px;\n          margin-right: 2px;\n          background-color: transparent; }\n\n.igv-ruler-tooltip {\n  pointer-events: none;\n  z-index: 128;\n  position: absolute;\n  top: 0;\n  left: 0;\n  width: 1px;\n  height: 32px;\n  background-color: transparent;\n  display: flex;\n  flex-flow: row;\n  flex-wrap: nowrap;\n  justify-content: flex-start;\n  align-items: center; }\n  .igv-ruler-tooltip > div {\n    pointer-events: none;\n    width: 128px;\n    height: auto;\n    padding: 1px;\n    color: #373737;\n    font-size: 10px;\n    font-family: \"Open Sans\", sans-serif;\n    font-weight: 400;\n    background-color: white;\n    border-style: solid;\n    border-width: thin;\n    border-color: #373737; }\n\n.igv-multi-locus-separator {\n  pointer-events: none;\n  user-select: none;\n  -moz-user-select: none;\n  -webkit-user-select: none;\n  position: absolute;\n  top: 0;\n  bottom: 0;\n  z-index: 2;\n  width: 1px;\n  background-color: gray; }\n\n.igv-track-container-spinner {\n  position: absolute;\n  top: 90%;\n  left: 50%;\n  transform: translate(-50%, -50%);\n  z-index: 1024;\n  width: 24px;\n  height: 24px;\n  pointer-events: none;\n  color: #737373; }\n\n.igv-right-hand-gutter {\n  position: relative;\n  width: 36px;\n  height: 100%;\n  background: white; }\n\n.igv-canvas {\n  position: relative;\n  display: block; }\n\n.igv-ideogram-canvas {\n  position: absolute;\n  top: 0;\n  left: 0;\n  display: block; }\n\n.igv-sample-name-viewport-hover {\n  z-index: 1042;\n  cursor: pointer;\n  pointer-events: none;\n  display: block;\n  position: absolute;\n  width: auto;\n  font-size: 12px;\n  color: black;\n  font-family: sans-serif;\n  text-transform: uppercase;\n  vertical-align: middle;\n  background-color: white;\n  padding: 1px;\n  border-style: solid;\n  border-width: thin;\n  border-color: rgba(0, 0, 0, 0.125); }\n\n.igv-scrollbar-outer-div {\n  position: relative;\n  width: 14px;\n  height: 100%;\n  background-color: white; }\n  .igv-scrollbar-outer-div > div {\n    cursor: pointer;\n    position: absolute;\n    top: 0;\n    left: 2px;\n    width: 8px;\n    border-width: 1px;\n    border-style: solid;\n    border-color: #c4c4c4;\n    border-top-left-radius: 4px;\n    border-top-right-radius: 4px;\n    border-bottom-left-radius: 4px;\n    border-bottom-right-radius: 4px;\n    background-color: transparent; }\n  .igv-scrollbar-outer-div > div:hover {\n    background-color: #c4c4c4; }\n\n.igv-viewport-border-right {\n  border-right-color: #292929;\n  border-right-style: solid;\n  border-right-width: 1px; }\n\n.igv-viewport-ruler {\n  cursor: pointer;\n  font-family: \"Open Sans\", sans-serif;\n  font-size: 10px;\n  font-weight: 200;\n  text-align: center; }\n  .igv-viewport-ruler > div {\n    height: 100%; }\n\n.igv-track-manipulation-handle {\n  position: relative;\n  cursor: pointer;\n  width: 12px;\n  height: 100%;\n  margin-left: 0;\n  font-size: medium;\n  border-color: #c4c4c4;\n  border-style: solid;\n  border-width: 0;\n  border-top-right-radius: 6px;\n  border-bottom-right-radius: 6px;\n  z-index: 512;\n  background-color: #c4c4c4; }\n\n.igv-track-manipulation-handle:hover,\n.igv-track-manipulation-handle:focus,\n.igv-track-manipulation-handle:active {\n  border-color: #7e7e7e;\n  background-color: #7e7e7e; }\n\n.igv-multi-locus-panel-border {\n  position: absolute;\n  top: 0;\n  left: 0;\n  height: 100%;\n  width: 1px;\n  background-color: green;\n  border-right-color: #ff0000;\n  border-right-style: solid;\n  border-right-width: 1px; }\n\n.igv-navbar-button {\n  box-sizing: unset;\n  padding-left: 6px;\n  padding-right: 6px;\n  height: 18px;\n  text-transform: capitalize;\n  user-select: none;\n  line-height: 18px;\n  text-align: center;\n  vertical-align: middle;\n  font-family: \"Open Sans\", sans-serif;\n  font-size: 11px;\n  font-weight: 200;\n  color: #737373;\n  background-color: #f3f3f3;\n  border-color: #737373;\n  border-style: solid;\n  border-width: thin;\n  border-radius: 6px; }\n\n.igv-navbar-button-clicked {\n  color: white;\n  background-color: #737373; }\n\n.igv-navbar-button:hover {\n  cursor: pointer; }\n\n.igv-logo-nonav {\n  margin-left: 4px;\n  margin-top: 12px;\n  position: absolute;\n  top: 0;\n  left: 0;\n  width: 34px;\n  height: 16px; }\n\n.igv-search-results {\n  position: absolute;\n  top: 32px;\n  left: 2px;\n  height: 320px;\n  width: 213px;\n  background-color: white;\n  border-color: #7F7F7F;\n  border-style: solid;\n  border-width: thin;\n  overflow-x: hidden;\n  overflow-y: auto;\n  z-index: 9999; }\n  .igv-search-results tr {\n    font-family: \"Open Sans\", sans-serif;\n    font-size: small;\n    font-weight: 400;\n    color: #444; }\n  .igv-search-results tr:hover,\n  .igv-search-results tr:focus,\n  .igv-search-results tr:active {\n    cursor: pointer;\n    font-weight: 700;\n    color: #141414; }\n\n.igv-viewport-message {\n  position: absolute;\n  top: 50%;\n  left: 50%;\n  transform: translate(-50%, -50%);\n  color: rgba(0, 0, 0, 0.15);\n  font-family: \"Open Sans\", sans-serif;\n  font-size: 25px;\n  font-weight: bold;\n  user-select: none; }\n\n.igv-whole-genome-container {\n  display: flex;\n  flex-flow: row;\n  flex-wrap: nowrap;\n  justify-content: space-between;\n  width: 100%;\n  height: 100%;\n  background-color: white; }\n  .igv-whole-genome-container div {\n    font-family: \"Open Sans\", sans-serif;\n    font-size: 10px;\n    font-weight: 400;\n    color: #444;\n    height: 100%;\n    text-align: center;\n    border-right-color: #bfbfbf;\n    border-right-style: solid;\n    border-right-width: thin; }\n    .igv-whole-genome-container div span {\n      display: block;\n      padding-top: 6px;\n      text-overflow: ellipsis; }\n  .igv-whole-genome-container div:last-child {\n    border-right-color: transparent; }\n  .igv-whole-genome-container div:hover,\n  .igv-whole-genome-container div:focus,\n  .igv-whole-genome-container div:active {\n    cursor: pointer;\n    background-color: #efefef; }\n\n.igv-multi-locus-panel-close-container {\n  position: absolute;\n  top: 4px;\n  right: 4px;\n  width: 16px;\n  height: 16px;\n  color: #666666;\n  z-index: 1000; }\n\n.igv-multi-locus-panel-close-container:hover {\n  cursor: pointer;\n  color: #434343; }\n\n.igv-multi-locus-panel-label-div {\n  position: absolute;\n  left: 50%;\n  top: 15%;\n  transform: translate(-50%, -25%);\n  font-family: \"Open Sans\", sans-serif;\n  font-size: 12px;\n  font-weight: 400;\n  text-align: center;\n  min-width: 16px;\n  z-index: 64;\n  color: #373737;\n  background-color: white;\n  padding: 1px; }\n\n.igv-multi-locus-panel-label-div:hover {\n  cursor: pointer; }\n\n.igv-viewport-spinner {\n  position: absolute;\n  top: 50%;\n  left: 50%;\n  transform: translate(-50%, -50%);\n  z-index: 1024;\n  width: 24px;\n  height: 24px;\n  pointer-events: none;\n  color: #737373; }\n\n.igv-ruler-sweeper-div {\n  display: none;\n  pointer-events: none;\n  position: absolute;\n  top: 0;\n  left: 0;\n  width: 0;\n  height: 100%;\n  z-index: 99999;\n  background-color: rgba(68, 134, 247, 0.25); }\n\n.igv-track-menu-border-top {\n  border-top-color: #a2a2a2;\n  border-top-style: solid;\n  border-top-width: thin; }\n\n.igv-track-menu-category {\n  padding-left: 4px;\n  font-weight: 400; }\n\n.igv-track-drag-scrim {\n  position: absolute;\n  left: 0;\n  top: 0;\n  width: 100%;\n  height: 100%;\n  z-index: 256;\n  background-color: rgba(68, 134, 247, 0.25); }\n\n.igv-trackgear-container {\n  position: relative;\n  width: 20px;\n  height: 20px;\n  margin-left: 4px;\n  color: #7F7F7F; }\n\n.igv-trackgear-container:hover {\n  cursor: pointer;\n  color: #444; }\n\n.igv-track-label {\n  position: absolute;\n  left: 8px;\n  top: 3px;\n  width: auto;\n  height: auto;\n  max-width: 200px;\n  padding-left: 3px;\n  padding-right: 3px;\n  white-space: nowrap;\n  overflow: hidden;\n  text-overflow: ellipsis;\n  font-family: \"Open Sans\", sans-serif;\n  font-size: small;\n  font-weight: 400;\n  text-align: center;\n  user-select: none;\n  -moz-user-select: none;\n  -webkit-user-select: none;\n  border-color: #444;\n  border-radius: 2px;\n  border-style: solid;\n  border-width: thin;\n  background-color: white;\n  z-index: 128;\n  cursor: pointer; }\n\n.igv-track-label:hover,\n.igv-track-label:focus,\n.igv-track-label:active {\n  background-color: #f0f0f0; }\n\n.zoom-in-notice-container {\n  position: absolute;\n  top: 10px;\n  left: 50%; }\n  .zoom-in-notice-container div {\n    position: relative;\n    left: -50%;\n    font-family: \"Open Sans\", sans-serif;\n    font-size: medium;\n    font-weight: 400;\n    color: #3f3f3f;\n    background-color: rgba(255, 255, 255, 0.51);\n    z-index: 64; }\n\n.igv-center-guide {\n  pointer-events: none;\n  position: absolute;\n  top: 0;\n  bottom: 0;\n  left: 50%;\n  width: 8px;\n  z-index: 8;\n  display: none;\n  user-select: none;\n  -moz-user-select: none;\n  -webkit-user-select: none;\n  border-left-style: dashed;\n  border-left-width: thin;\n  border-right-style: dashed;\n  border-right-width: thin; }\n\n.igv-center-guide-wide {\n  background-color: rgba(0, 0, 0, 0);\n  border-left-color: rgba(127, 127, 127, 0.51);\n  border-right-color: rgba(127, 127, 127, 0.51); }\n\n.igv-center-guide-thin {\n  left: 50%;\n  width: 1px;\n  background-color: rgba(0, 0, 0, 0);\n  border-left-color: rgba(127, 127, 127, 0.51);\n  border-right-color: rgba(0, 0, 0, 0);\n  /*background-color: rgba(127, 127, 127, 0.51);*/\n  /*border-left-color: rgba(0,0,0,0);*/\n  /*border-right-color: rgba(0,0,0,0);*/ }\n\n.igv-cursor-guide-horizontal {\n  pointer-events: none;\n  user-select: none;\n  -moz-user-select: none;\n  -webkit-user-select: none;\n  position: absolute;\n  left: 0;\n  right: 0;\n  top: 50%;\n  height: 1px;\n  z-index: 1;\n  border-top-style: dotted;\n  border-top-width: thin;\n  border-top-color: rgba(127, 127, 127, 0.76);\n  display: none; }\n\n.igv-cursor-guide-vertical {\n  pointer-events: none;\n  user-select: none;\n  -moz-user-select: none;\n  -webkit-user-select: none;\n  position: absolute;\n  top: 0;\n  bottom: 0;\n  left: 50%;\n  width: 1px;\n  z-index: 1;\n  border-left-style: dotted;\n  border-left-width: thin;\n  border-left-color: rgba(127, 127, 127, 0.76);\n  display: none; }\n\n.igv-clickable {\n  cursor: pointer;\n  background-color: white; }\n\n#color-by-tag {\n  color: #444; }\n\n#color-by-tag:hover,\n#color-by-tag:focus,\n#color-by-tag:active {\n  cursor: pointer;\n  padding-left: 2px;\n  padding-right: 2px;\n  color: white;\n  border-color: #444;\n  border-radius: 2px;\n  border-style: solid;\n  border-width: thin;\n  background-color: #7f7f7f; }\n\n.igv-ellipsis {\n  white-space: nowrap;\n  overflow: hidden;\n  text-overflow: ellipsis; }\n\n.igv-spinner-container {\n  color: #3f3f3f;\n  width: 100%;\n  height: 100%;\n  text-align: center;\n  padding-top: 8px;\n  font-size: 24px;\n  z-index: 512; }\n\n.igv-fa-check-visible {\n  color: inherit;\n  padding-right: 2px; }\n\n.igv-fa-check-hidden {\n  color: transparent;\n  padding-right: 2px; }\n\n.validateTips {\n  border: 1px solid transparent;\n  padding: 0.3em; }\n  .validateTips fieldset {\n    border: 0; }\n\n.igv-spacer-10 {\n  height: 10px;\n  width: 100%;\n  font-size: 0;\n  margin: 0;\n  padding: 0;\n  border: 0;\n  display: block; }\n\n.igv-fa5-spin {\n  -webkit-animation: igv-fa5-spin 2s infinite linear;\n  animation: igv-fa5-spin 2s infinite linear; }\n\n@-webkit-keyframes igv-fa5-spin {\n  0% {\n    -webkit-transform: rotate(0deg);\n    transform: rotate(0deg); }\n  100% {\n    -webkit-transform: rotate(360deg);\n    transform: rotate(360deg); } }\n@keyframes igv-fa5-spin {\n  0% {\n    -webkit-transform: rotate(0deg);\n    transform: rotate(0deg); }\n  100% {\n    -webkit-transform: rotate(360deg);\n    transform: rotate(360deg); } }\n\n/*# sourceMappingURL=igv.css.map */\n';
+      var style = document.createElement('style');
+      style.setAttribute('type', 'text/css');
+      style.innerHTML = css;
+      document.head.insertBefore(style, document.head.childNodes[document.head.childNodes.length - 1]);
+    }
+
+    // Defines the top-level API for the igv module
+    const setApiKey = igvxhr.setApiKey;
+    embedCSS();
+
+    function setGoogleOauthToken(accessToken) {
+      return oauth.setToken(accessToken);
+    }
+
+    function setOauthToken(accessToken, host) {
+      return oauth.setToken(accessToken, host);
+    }
+
+    var index = {
+      IGVGraphics,
+      MenuUtils,
+      DataRangeDialog,
+      createTrack,
+      createBrowser,
+      removeBrowser,
+      removeAllBrowsers,
+      visibilityChange,
+      setGoogleOauthToken,
+      setOauthToken,
+      oauth,
+      version,
+      setApiKey,
+      doAutoscale,
+      TrackView
+    };
+
+    return index;
+
+})));
\ No newline at end of file
diff --git a/public/igv_custom.js b/public/igv_custom.js
new file mode 100644
index 0000000..0af6668
--- /dev/null
+++ b/public/igv_custom.js
@@ -0,0 +1,222 @@
+// igv_custom.js
+// IGV 브라우저가 생성된 후, 파란색 라인 2개를 ideogram/viewport에 추가하고 드래그로 이동 가능하게 함
+// 라인 위치 변경 시 window에 커스텀 이벤트('igv-blue-lines-changed')를 dispatch
+
+(function() {
+  // 설정값
+  const LINE_COLOR = '#007bff';
+  const LINE_WIDTH = 2;
+  const INIT_RATIO_1 = 0.3; // 30% 위치
+  const INIT_RATIO_2 = 0.7; // 70% 위치
+
+  // 내부 상태
+  let viewportRect = null;
+  let dragging = null; // 'start' or 'end' or null
+  let dragOffset = 0;
+  let startRatio = INIT_RATIO_1;
+  let endRatio = INIT_RATIO_2;
+
+  // 라인 DOM
+  let viewportLines = [];
+  let viewportFill = null;
+  let ideogramLines = [];
+  let ideogramFill = null;
+
+  // IGV가 준비되면 실행
+  function waitForIGVAndInit() {
+    const check = () => {
+      const viewport = document.querySelector('.igv-viewport-content');
+      if (viewport) {
+        setupLines();
+      } else {
+        setTimeout(check, 300);
+      }
+    };
+    check();
+  }
+
+  // 라인 생성 및 이벤트 바인딩
+  function setupLines() {
+    // 모든 파란 라인 삭제
+    document.querySelectorAll('.igv-blue-line').forEach(el => el.remove());
+    // 기존 fill 오버레이 삭제
+    document.querySelectorAll('.igv-blue-fill').forEach(el => el.remove());
+
+    // 모든 .igv-viewport-content 중, height가 16px 초과인 첫 번째를 메인 뷰포트로 간주
+    const viewports = Array.from(document.querySelectorAll('.igv-viewport-content'));
+    const mainViewport = viewports.find(vp => {
+      const h = vp.offsetHeight || parseInt(vp.style.height, 10);
+      return h > 16;
+    });
+    if (!mainViewport) return;
+
+    // 이미 있으면 중복 생성 방지
+    if (mainViewport.parentNode.querySelector('.igv-blue-line')) return;
+
+    viewportRect = mainViewport.getBoundingClientRect();
+
+    // 라인 2개 생성 (뷰포트)
+    viewportLines = [createLine('start', 'viewport', mainViewport), createLine('end', 'viewport', mainViewport)];
+    viewportLines.forEach(line => mainViewport.parentNode.appendChild(line));
+    // fill 오버레이 생성 및 추가 (뷰포트)
+    viewportFill = document.createElement('div');
+    viewportFill.className = 'igv-blue-fill';
+    Object.assign(viewportFill.style, {
+      position: 'absolute',
+      top: (viewportRect.top - mainViewport.getBoundingClientRect().top) + 'px',
+      height: viewportRect.height + 'px',
+      background: 'rgba(0,123,255,0.18)',
+      zIndex: 999,
+      pointerEvents: 'none',
+      borderRadius: '2px',
+      transition: 'left 0.08s, width 0.08s',
+    });
+    mainViewport.parentNode.appendChild(viewportFill);
+
+    // === ideogram(미니맵)에도 라인/오버레이 추가 ===
+    const ideogram = document.querySelector('.igv-ideogram-content') || document.querySelector('.igv-ideogram');
+    if (ideogram) {
+      const ideogramRect = ideogram.getBoundingClientRect();
+      ideogramLines = [createLine('start', 'ideogram', ideogram), createLine('end', 'ideogram', ideogram)];
+      ideogramLines.forEach(line => ideogram.parentNode.appendChild(line));
+      ideogramFill = document.createElement('div');
+      ideogramFill.className = 'igv-blue-fill';
+      Object.assign(ideogramFill.style, {
+        position: 'absolute',
+        top: (ideogramRect.top - ideogram.parentNode.getBoundingClientRect().top) + 'px',
+        height: ideogramRect.height + 'px',
+        background: 'rgba(0,123,255,0.18)',
+        zIndex: 999,
+        pointerEvents: 'none',
+        borderRadius: '2px',
+        transition: 'left 0.08s, width 0.08s',
+      });
+      ideogram.parentNode.appendChild(ideogramFill);
+    }
+
+    updateLinePositions();
+    bindDragEvents();
+  }
+
+  // 라인 DOM 생성
+  function createLine(which, area, parentEl) {
+    const line = document.createElement('div');
+    line.className = 'igv-blue-line';
+    line.dataset.which = which;
+    line.dataset.area = area;
+    line._parentEl = parentEl; // 커스텀 속성으로 부모 저장
+    Object.assign(line.style, {
+      position: 'absolute',
+      top: area === 'ideogram' ? (viewportRect.top - parentEl.getBoundingClientRect().top) + 'px' : (viewportRect.top - parentEl.getBoundingClientRect().top) + 'px',
+      width: LINE_WIDTH + 'px',
+      height: area === 'ideogram' ? viewportRect.height + 'px' : viewportRect.height + 'px',
+      background: LINE_COLOR,
+      zIndex: 1000,
+      cursor: 'ew-resize',
+      userSelect: 'none',
+    });
+    line.addEventListener('mousedown', (e) => startDrag(which, e));
+    return line;
+  }
+
+  // 라인 위치 갱신
+  function updateLinePositions() {
+    viewportRect = document.querySelector('.igv-viewport-content').getBoundingClientRect();
+    let baseArea = document.querySelector('.igv-viewport-content canvas, .igv-viewport-content svg');
+    let baseRect = baseArea ? baseArea.getBoundingClientRect() : viewportRect;
+    // viewport 라인 위치 (실제 베이스 표시 영역 기준)
+    const baseWidth = baseRect.width;
+    const baseLeft = baseRect.left;
+    const startX_view = baseLeft + baseWidth * startRatio;
+    const endX_view = baseLeft + baseWidth * endRatio;
+    viewportLines[0].style.left = (startX_view - viewportLines[0]._parentEl.getBoundingClientRect().left) + 'px';
+    viewportLines[1].style.left = (endX_view - viewportLines[1]._parentEl.getBoundingClientRect().left) + 'px';
+    // fill 오버레이 위치/크기 갱신
+    if (viewportFill) {
+      const left = Math.min(startX_view, endX_view) - viewportFill.parentNode.getBoundingClientRect().left;
+      const width = Math.abs(endX_view - startX_view);
+      viewportFill.style.left = left + 'px';
+      viewportFill.style.width = width + 'px';
+    }
+    // === ideogram(미니맵) 라인/오버레이 위치 갱신 ===
+    const ideogram = document.querySelector('.igv-ideogram-content') || document.querySelector('.igv-ideogram');
+    if (ideogram && ideogramLines.length === 2 && ideogramFill) {
+      const ideogramRect = ideogram.getBoundingClientRect();
+      const ideogramWidth = ideogramRect.width;
+      const ideogramLeft = ideogramRect.left;
+      const startX_ideo = ideogramLeft + ideogramWidth * startRatio;
+      const endX_ideo = ideogramLeft + ideogramWidth * endRatio;
+      ideogramLines[0].style.left = (startX_ideo - ideogram.parentNode.getBoundingClientRect().left) + 'px';
+      ideogramLines[1].style.left = (endX_ideo - ideogram.parentNode.getBoundingClientRect().left) + 'px';
+      // fill
+      const left = Math.min(startX_ideo, endX_ideo) - ideogramFill.parentNode.getBoundingClientRect().left;
+      const width = Math.abs(endX_ideo - startX_ideo);
+      ideogramFill.style.left = left + 'px';
+      ideogramFill.style.width = width + 'px';
+    }
+  }
+
+  // 드래그 이벤트 바인딩
+  function bindDragEvents() {
+    document.addEventListener('mousemove', onDrag);
+    document.addEventListener('mouseup', stopDrag);
+  }
+
+  function startDrag(which, e) {
+    dragging = which;
+    dragOffset = e.clientX;
+    e.preventDefault();
+    e.stopPropagation();
+  }
+
+  function onDrag(e) {
+    if (!dragging) return;
+    const areaWidth = viewportRect.width;
+    let x = e.clientX - viewportRect.left;
+    let ratio = x / areaWidth;
+    ratio = Math.max(0, Math.min(1, ratio));
+    if (dragging === 'start') {
+      startRatio = Math.min(ratio, endRatio - 0.01);
+    } else {
+      endRatio = Math.max(ratio, startRatio + 0.01);
+    }
+    updateLinePositions();
+    fireChangeEvent();
+  }
+
+  function stopDrag() {
+    dragging = null;
+  }
+
+  // 라인 위치 변경 이벤트 발생
+  function fireChangeEvent() {
+    console.log('fireChangeEvent 호출됨', { startRatio, endRatio });
+    window.dispatchEvent(new CustomEvent('igv-blue-lines-changed', {
+      detail: {
+        startRatio,
+        endRatio
+      }
+    }));
+  }
+
+  // 외부에서 라인 위치를 강제로 지정할 수 있도록 export
+  window.igvCustom = {
+    setLineRatios: (start, end) => {
+      startRatio = start;
+      endRatio = end;
+      updateLinePositions();
+      fireChangeEvent();
+    },
+    getLineRatios: () => ({ startRatio, endRatio }),
+    setupLines: setupLines
+  };
+
+  // 스타일 추가
+  const style = document.createElement('style');
+  style.innerHTML = `.igv-blue-line { pointer-events: auto !important; }
+  .igv-blue-fill { pointer-events: none !important; }`;
+  document.head.appendChild(style);
+
+  // IGV가 준비되면 실행
+  setTimeout(waitForIGVAndInit, 1000);
+})(); 
\ No newline at end of file