{"version":3,"file":"static/js/3525.e74d3ff0.chunk.js","mappings":"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","sources":["../../../node_modules/@gmod/nclist/src/util.ts","../../../node_modules/@gmod/nclist/src/nclist.ts","../../../node_modules/@gmod/nclist/src/array_representation.ts","../../../node_modules/@gmod/nclist/src/lazy_array.ts","../../../node_modules/@gmod/nclist/src/feature_store.ts","../../../node_modules/@gmod/nclist/src/index.ts","../../../plugins/legacy-jbrowse/src/NCListAdapter/NCListFeature.ts","../../../plugins/legacy-jbrowse/src/NCListAdapter/NCListAdapter.ts","../../../node_modules/@gmod/abortable-promise-cache/src/AggregateAbortController.ts","../../../node_modules/@gmod/abortable-promise-cache/src/AggregateStatusReporter.ts","../../../node_modules/@gmod/abortable-promise-cache/src/AbortablePromiseCache.ts","../../../node_modules/@jridgewell/resolve-uri/src/resolve-uri.ts"],"sourcesContent":["//@ts-nocheck\nimport resolve from '@jridgewell/resolve-uri'\n\nexport async function readJSON(url, readFile, options = {}) {\n  const { defaultContent = {} } = options\n  let str\n  try {\n    str = await readFile(url, { encoding: 'utf8' })\n    return JSON.parse(str)\n  } catch (error) {\n    if (\n      error.code === 'ENOENT' ||\n      error.status === 404 ||\n      error.message.includes('404') ||\n      error.message.includes('ENOENT')\n    ) {\n      return defaultContent\n    }\n    throw error\n  }\n}\n\nexport function foo() {}\n\nexport function newURL(arg: string, base?: string = '.') {\n  return resolve(arg, base)\n}\n","//@ts-nocheck\nimport QuickLRU from 'quick-lru'\nimport AbortablePromiseCache from '@gmod/abortable-promise-cache'\nimport { newURL, readJSON } from './util'\n\nexport default class NCList {\n  constructor({ readFile, cacheSize = 100 }) {\n    this.topList = []\n    this.chunkCache = new AbortablePromiseCache({\n      cache: new QuickLRU({ maxSize: cacheSize }),\n      fill: this.readChunkItems.bind(this),\n    })\n    this.readFile = readFile\n    if (!this.readFile) {\n      throw new Error(`must provide a \"readFile\" function`)\n    }\n  }\n\n  importExisting(nclist, attrs, baseURL, lazyUrlTemplate, lazyClass) {\n    this.topList = nclist\n    this.attrs = attrs\n    this.start = attrs.makeFastGetter('Start')\n    this.end = attrs.makeFastGetter('End')\n    this.lazyClass = lazyClass\n    this.baseURL = baseURL\n    this.lazyUrlTemplate = lazyUrlTemplate\n  }\n\n  binarySearch(arr, item, getter) {\n    let low = -1\n    let high = arr.length\n    let mid\n\n    while (high - low > 1) {\n      mid = (low + high) >>> 1\n      if (getter(arr[mid]) >= item) {\n        high = mid\n      } else {\n        low = mid\n      }\n    }\n\n    // if we're iterating rightward, return the high index;\n    // if leftward, the low index\n    if (getter === this.end) {\n      return high\n    }\n    return low\n  }\n\n  readChunkItems(chunkNum) {\n    const url = newURL(\n      this.lazyUrlTemplate.replace(/\\{Chunk\\}/gi, chunkNum),\n      this.baseURL,\n    )\n    return readJSON(url, this.readFile, { defaultContent: [] })\n  }\n\n  async *iterateSublist(arr, from, to, inc, searchGet, testGet, path) {\n    const getChunk = this.attrs.makeGetter('Chunk')\n    const getSublist = this.attrs.makeGetter('Sublist')\n\n    const pendingPromises = []\n    for (\n      let i = this.binarySearch(arr, from, searchGet);\n      i < arr.length && i >= 0 && inc * testGet(arr[i]) < inc * to;\n      i += inc\n    ) {\n      if (arr[i][0] === this.lazyClass) {\n        // this is a lazily-loaded chunk of the nclist\n        const chunkNum = getChunk(arr[i])\n        const chunkItemsP = this.chunkCache\n          .get(chunkNum, chunkNum)\n          .then(item => [item, chunkNum])\n        pendingPromises.push(chunkItemsP)\n      } else {\n        // this is just a regular feature\n        yield [arr[i], path.concat(i)]\n      }\n\n      // if this node has a contained sublist, process that too\n      const sublist = getSublist(arr[i])\n      if (sublist) {\n        yield* this.iterateSublist(\n          sublist,\n          from,\n          to,\n          inc,\n          searchGet,\n          testGet,\n          path.concat(i),\n        )\n      }\n    }\n\n    for (let i = 0; i < pendingPromises.length; i += 1) {\n      const [item, chunkNum] = await pendingPromises[i]\n      if (item) {\n        yield* this.iterateSublist(item, from, to, inc, searchGet, testGet, [\n          ...path,\n          chunkNum,\n        ])\n      }\n    }\n  }\n\n  async *iterate(from, to) {\n    // calls the given function once for each of the\n    // intervals that overlap the given interval\n    // if from <= to, iterates left-to-right, otherwise iterates right-to-left\n\n    // inc: iterate leftward or rightward\n    const inc = from > to ? -1 : 1\n    // searchGet: search on start or end\n    const searchGet = from > to ? this.start : this.end\n    // testGet: test on start or end\n    const testGet = from > to ? this.end : this.start\n\n    if (this.topList.length > 0) {\n      yield* this.iterateSublist(\n        this.topList,\n        from,\n        to,\n        inc,\n        searchGet,\n        testGet,\n        [0],\n      )\n    }\n  }\n\n  async histogram(from, to, numBins) {\n    // calls callback with a histogram of the feature density\n    // in the given interval\n\n    const result = new Array(numBins)\n    result.fill(0)\n    const binWidth = (to - from) / numBins\n    for await (const feat of this.iterate(from, to)) {\n      const firstBin = Math.max(0, ((this.start(feat) - from) / binWidth) | 0)\n      const lastBin = Math.min(\n        numBins,\n        ((this.end(feat) - from) / binWidth) | 0,\n      )\n      for (let bin = firstBin; bin <= lastBin; bin += 1) {\n        result[bin] += 1\n      }\n    }\n    return result\n  }\n}\n","//@ts-nocheck\n/**\n * @class ArrayRepr\n *\n * Class for operating on indexed array representations of objects.\n *\n * For example, if we have a lot of objects with similar attributes, e.g.:\n *\n * <pre class=\"code\">\n *     [\n *         {start: 1, end: 2, strand: -1},\n *         {start: 5, end: 6, strand: 1},\n *         ...\n *     ]\n * </pre>\n *\n * @description\n * we can represent them more compactly (e.g., in JSON) something like this:\n *\n * <pre class=\"code\">\n *     class = [\"start\", \"end\", \"strand\"]\n *     [\n *         [1, 2, -1],\n *         [5, 6, 1],\n *         ...\n *     ]\n * </pre>\n *\n * If we want to represent a few different kinds of objects in our big list,\n * we can have multiple \"class\" arrays, and tag each object to identify\n * which \"class\" array describes it.\n *\n * For example, if we have a lot of instances of a few types of objects,\n * like this:\n *\n * <pre class=\"code\">\n *     [\n *         {start: 1, end: 2, strand: 1, id: 1},\n *         {start: 5, end: 6, strand: 1, id: 2},\n *         ...\n *         {start: 10, end: 20, chunk: 1},\n *         {start: 30, end: 40, chunk: 2},\n *         ...\n *     ]\n * </pre>\n *\n * We could use the first array position to indicate the \"class\" for the\n * object, like this:\n *\n * <pre class=\"code\">\n *     classes = [[\"start\", \"end\", \"strand\", \"id\"], [\"start\", \"end\", \"chunk\"]]\n *     [\n *         [0, 1, 2, 1, 1],\n *         [0, 5, 6, 1, 2],\n *         ...\n *         [1, 10, 20, 1],\n *         [1, 30, 40, 1]\n *     ]\n * </pre>\n *\n * Also, if we occasionally want to add an ad-hoc attribute, we could just\n * stick an optional dictionary onto the end:\n *\n * <pre class=\"code\">\n *     classes = [[\"start\", \"end\", \"strand\", \"id\"], [\"start\", \"end\", \"chunk\"]]\n *     [\n *         [0, 1, 2, 1, 1],\n *         [0, 5, 6, 1, 2, {foo: 1}]\n *     ]\n * </pre>\n *\n * Given that individual objects are being represented by arrays, generic\n * code needs some way to differentiate arrays that are meant to be objects\n * from arrays that are actually meant to be arrays.\n * So for each class, we include a dict with <attribute name>: true mappings\n * for each attribute that is meant to be an array.\n *\n * Also, in cases where some attribute values are the same for all objects\n * in a particular set, it may be convenient to define a \"prototype\"\n * with default values for all objects in the set\n *\n * In the end, we get something like this:\n *\n * <pre class=\"code\">\n *     classes=[\n *         {'attributes': ['Start', 'End', 'Subfeatures'],\n *          'proto': {'Chrom': 'chr1'},\n *          'isArrayAttr': {Subfeatures: true}}\n *         ]\n * </pre>\n *\n * That's what this class facilitates.\n */\nclass ArrayRepr {\n  constructor(classes) {\n    this.classes = classes\n    this.fields = []\n    for (let cl = 0; cl < classes.length; cl += 1) {\n      this.fields[cl] = {}\n      for (let f = 0; f < classes[cl].attributes.length; f += 1) {\n        this.fields[cl][classes[cl].attributes[f]] = f + 1\n      }\n      if (classes[cl].proto === undefined) {\n        classes[cl].proto = {}\n      }\n      if (classes[cl].isArrayAttr === undefined) {\n        classes[cl].isArrayAttr = {}\n      }\n    }\n  }\n\n  /**\n   * @private\n   */\n  attrIndices(attr) {\n    return this.classes.map(\n      x =>\n        x.attributes.indexOf(attr) + 1 ||\n        x.attributes.indexOf(attr.toLowerCase()) + 1 ||\n        undefined,\n    )\n  }\n\n  get(obj, attr) {\n    if (attr in this.fields[obj[0]]) {\n      return obj[this.fields[obj[0]][attr]]\n    }\n\n    // try lowercase\n    const lcattr = attr.toLowerCase()\n    if (lcattr in this.fields[obj[0]]) {\n      return obj[this.fields[obj[0]][lcattr]]\n    }\n\n    const adhocIndex = this.classes[obj[0]].attributes.length + 1\n    if (adhocIndex >= obj.length || !(attr in obj[adhocIndex])) {\n      if (attr in this.classes[obj[0]].proto) {\n        return this.classes[obj[0]].proto[attr]\n      }\n      return undefined\n    }\n    return obj[adhocIndex][attr]\n  }\n\n  makeSetter(attr) {\n    return (obj, val) => {\n      this.set(obj, attr, val)\n    }\n  }\n\n  makeGetter(attr) {\n    return obj => {\n      return this.get(obj, attr)\n    }\n  }\n\n  makeFastGetter(attr) {\n    // can be used only if attr is guaranteed to be in\n    // the \"classes\" array for this object\n    const indices = this.attrIndices(attr)\n    return function get(obj) {\n      if (indices[obj[0]] !== undefined) {\n        return obj[indices[obj[0]]]\n      }\n      return undefined\n    }\n  }\n\n  // construct(self, obj, klass) {\n  //   const result = new Array(self.classes[klass].length)\n  //   Object.keys(obj).forEach(attr => {\n  //     this.set(result, attr, obj[attr])\n  //   })\n  //   return result\n  // }\n\n  /**\n   * Returns fast pre-compiled getter and setter functions for use with\n   * Arrays that use this representation.\n   * When the returned <code>get</code> and <code>set</code> functions are\n   * added as methods to an Array that contains data in this\n   * representation, they provide fast access by name to the data.\n   *\n   * @returns {Object} <code>{ get: function() {...}, set: function(val) {...} }</code>\n   *\n   * @example\n   * var accessors = attrs.accessors();\n   * var feature = get_feature_from_someplace();\n   * feature.get = accessors.get;\n   * // print out the feature start and end\n   * console.log( feature.get('start') + ',' + feature.get('end') );\n   */\n  accessors() {\n    if (!this._accessors) {\n      this._accessors = this._makeAccessors()\n    }\n    return this._accessors\n  }\n\n  /**\n   * @private\n   */\n  _makeAccessors() {\n    const indices = {}\n\n    const accessors = {\n      get(field) {\n        const f = this.get.field_accessors[field.toLowerCase()]\n        if (f) {\n          return f.call(this)\n        }\n        return undefined\n      },\n      set(field, val) {\n        const f = this.set.field_accessors[field]\n        if (f) {\n          return f.call(this, val)\n        }\n        return undefined\n      },\n      tags() {\n        return tags[this[0]] || []\n      },\n    }\n    accessors.get.field_accessors = {}\n    accessors.set.field_accessors = {}\n\n    // make a data structure as: { attr_name: [offset,offset,offset], }\n    // that will be convenient for finding the location of the attr\n    // for a given class like: indexForAttr{attrname}[classnum]\n    this.classes.forEach((cdef, classnum) => {\n      ;(cdef.attributes || []).forEach((attrname, offset) => {\n        indices[attrname] = indices[attrname] || []\n        indices[attrname][classnum] = offset + 1\n\n        attrname = attrname.toLowerCase()\n\n        indices[attrname] = indices[attrname] || []\n        indices[attrname][classnum] = offset + 1\n      })\n    })\n\n    // lowercase all the class attributes\n    const tags = this.classes.map(c => c.attributes)\n\n    // use that to make precalculated get and set accessors for each field\n    Object.keys(indices).forEach(attrname => {\n      const attrIndices = indices[attrname]\n      // get\n      accessors.get.field_accessors[attrname] = !attrIndices\n        ? function get() {\n            return undefined\n          }\n        : function get() {\n            return this[attrIndices[this[0]]]\n          }\n\n      // // set\n      // accessors.set.field_accessors[attrname] = !attrIndices\n      //   ? () => undefined\n      //   : v => {\n      //       this[attrIndices[this[0]]] = v\n      //       return v\n      //     }\n    })\n\n    return accessors\n  }\n}\nexport default ArrayRepr\n\n/*\n\nCopyright (c) 2007-2010 The Evolutionary Software Foundation\n\nCreated by Mitchell Skinner <mitch_skinner@berkeley.edu>\n\nThis package and its accompanying libraries are free software; you can\nredistribute it and/or modify it under the terms of the LGPL (either\nversion 2.1, or at your option, any later version) or the Artistic\nLicense 2.0.  Refer to LICENSE for the full license text.\n\n*/\n","//@ts-nocheck\nimport QuickLRU from 'quick-lru'\nimport AbortablePromiseCache from '@gmod/abortable-promise-cache'\nimport { newURL, readJSON } from './util'\n\n/**\n * For a JSON array that gets too large to load in one go, this class\n * helps break it up into chunks and provides an\n * async API for using the information in the array.\n */\nexport default class LazyArray {\n  constructor(\n    { urlTemplate, chunkSize, length, cacheSize = 100, readFile },\n    baseUrl,\n  ) {\n    this.urlTemplate = urlTemplate\n    this.chunkSize = chunkSize\n    this.length = length\n    this.baseUrl = baseUrl === undefined ? '' : baseUrl\n    this.readFile = readFile\n    if (!readFile) {\n      throw new Error('must provide readFile callback')\n    }\n    this.chunkCache = new AbortablePromiseCache({\n      cache: new QuickLRU({ maxSize: cacheSize }),\n      fill: this.getChunk.bind(this),\n    })\n  }\n\n  /**\n   * call the callback on one element of the array\n   * @param i index\n   * @param callback callback, gets called with (i, value, param)\n   * @param param (optional) callback will get this as its last parameter\n   */\n  index(i, callback, param) {\n    this.range(i, i, callback, undefined, param)\n  }\n\n  /**\n   * async generator for the elements in the range [start,end]\n   *\n   * @param start index of first element to call the callback on\n   * @param end index of last element to call the callback on\n   */\n  async *range(start, end) {\n    start = Math.max(0, start)\n    end = Math.min(end, this.length - 1)\n\n    const firstChunk = Math.floor(start / this.chunkSize)\n    const lastChunk = Math.floor(end / this.chunkSize)\n\n    const chunkreadFiles = []\n    for (let chunk = firstChunk; chunk <= lastChunk; chunk += 1) {\n      chunkreadFiles.push(this.chunkCache.get(chunk, chunk))\n    }\n    for (let i = 0; i < chunkreadFiles.length; i += 1) {\n      const [chunkNumber, chunkData] = await chunkreadFiles[i]\n      yield* this.filterChunkData(start, end, chunkNumber, chunkData)\n    }\n  }\n\n  async getChunk(chunkNumber) {\n    let url = this.urlTemplate.replace(/\\{Chunk\\}/gi, chunkNumber)\n    if (this.baseUrl) {\n      url = newURL(url, this.baseUrl)\n    }\n    const data = await readJSON(url, this.readFile)\n    return [chunkNumber, data]\n  }\n\n  *filterChunkData(queryStart, queryEnd, chunkNumber, chunkData) {\n    // index (in the overall lazy array) of the first position in this chunk\n    const firstIndex = chunkNumber * this.chunkSize\n    const chunkStart = Math.max(0, queryStart - firstIndex)\n    const chunkEnd = Math.min(queryEnd - firstIndex, this.chunkSize - 1)\n    for (let i = chunkStart; i <= chunkEnd; i += 1) {\n      yield [i + firstIndex, chunkData[i]]\n    }\n  }\n}\n","//@ts-nocheck\nimport QuickLRU from 'quick-lru'\nimport AbortablePromiseCache from '@gmod/abortable-promise-cache'\n\nimport GenericNCList from './nclist'\nimport ArrayRepr from './array_representation'\nimport LazyArray from './lazy_array'\nimport { newURL, readJSON } from './util'\n\nfunction idfunc() {\n  return this._uniqueID\n}\nfunction parentfunc() {\n  return this._parent\n}\nfunction childrenfunc() {\n  return this.get('subfeatures')\n}\n\n/**\n * Sequence feature store using nested containment\n * lists held in JSON files that are lazily read.\n *\n * @param {object} args constructor args\n * @param {string} args.baseUrl base URL for resolving relative URLs\n * @param {string} args.urlTemplate Template string for\n *  the root file of each reference sequence. The reference sequence\n *  name will be interpolated into this string where `{refseq}` appears.\n * @param {function} args.readFile function to use for reading remote from URLs.\n */\nexport default class NCListStore {\n  constructor({ baseUrl, urlTemplate, readFile, cacheSize = 10 }) {\n    this.baseUrl = baseUrl\n    this.urlTemplates = { root: urlTemplate }\n\n    this.readFile = readFile\n    if (!this.readFile) {\n      throw new Error(`must provide a \"readFile\" function argument`)\n    }\n\n    this.dataRootCache = new AbortablePromiseCache({\n      cache: new QuickLRU({ maxSize: cacheSize }),\n      fill: this.fetchDataRoot.bind(this),\n    })\n  }\n\n  makeNCList() {\n    return new GenericNCList({ readFile: this.readFile })\n  }\n\n  loadNCList(refData, trackInfo, listUrl) {\n    refData.nclist.importExisting(\n      trackInfo.intervals.nclist,\n      refData.attrs,\n      listUrl,\n      trackInfo.intervals.urlTemplate,\n      trackInfo.intervals.lazyClass,\n    )\n  }\n\n  getDataRoot(refName) {\n    return this.dataRootCache.get(refName, refName)\n  }\n\n  fetchDataRoot(refName) {\n    const url = newURL(\n      this.urlTemplates.root.replace(/{\\s*refseq\\s*}/g, refName),\n      this.baseUrl,\n    )\n\n    // fetch the trackdata\n    return readJSON(url, this.readFile).then(trackInfo =>\n      // trackInfo = JSON.parse( trackInfo );\n      this.parseTrackInfo(trackInfo, url),\n    )\n  }\n\n  parseTrackInfo(trackInfo, url) {\n    const refData = {\n      nclist: this.makeNCList(),\n      stats: {\n        featureCount: trackInfo.featureCount || 0,\n      },\n    }\n\n    if (trackInfo.intervals) {\n      refData.attrs = new ArrayRepr(trackInfo.intervals.classes)\n      this.loadNCList(refData, trackInfo, url)\n    }\n\n    const { histograms } = trackInfo\n    if (histograms && histograms.meta) {\n      for (let i = 0; i < histograms.meta.length; i += 1) {\n        histograms.meta[i].lazyArray = new LazyArray(\n          { ...histograms.meta[i].arrayParams, readFile: this.readFile },\n          url,\n        )\n      }\n      refData._histograms = histograms\n    }\n\n    // parse any strings in the histogram data that look like numbers\n    if (refData._histograms) {\n      Object.keys(refData._histograms).forEach(key => {\n        const entries = refData._histograms[key]\n        entries.forEach(entry => {\n          Object.keys(entry).forEach(key2 => {\n            if (\n              typeof entry[key2] === 'string' &&\n              String(Number(entry[key2])) === entry[key2]\n            ) {\n              entry[key2] = Number(entry[key2])\n            }\n          })\n        })\n      })\n    }\n\n    return refData\n  }\n\n  async getRegionStats(query) {\n    const data = await this.getDataRoot(query.ref)\n    return data.stats\n  }\n\n  /**\n   * fetch binned counts of feature coverage in the given region.\n   *\n   * @param {object} query\n   * @param {string} query.refName reference sequence name\n   * @param {number} query.start region start\n   * @param {number} query.end region end\n   * @param {number} query.numBins number of bins desired in the feature counts\n   * @param {number} query.basesPerBin number of bp desired in each feature counting bin\n   * @returns {object} as:\n   *    `{ bins: hist, stats: statEntry }`\n   */\n  async getRegionFeatureDensities({\n    refName,\n    start,\n    end,\n    numBins,\n    basesPerBin,\n  }) {\n    const data = await this.getDataRoot(refName)\n    if (numBins) {\n      basesPerBin = (end - start) / numBins\n    } else if (basesPerBin) {\n      numBins = Math.ceil((end - start) / basesPerBin)\n    } else {\n      throw new TypeError(\n        'numBins or basesPerBin arg required for getRegionFeatureDensities',\n      )\n    }\n\n    // pick the relevant entry in our pre-calculated stats\n    const stats = data._histograms.stats || []\n    const statEntry = stats.find(entry => entry.basesPerBin >= basesPerBin)\n\n    // The histogramMeta array describes multiple levels of histogram detail,\n    // going from the finest (smallest number of bases per bin) to the\n    // coarsest (largest number of bases per bin).\n    // We want to use coarsest histogramMeta that's at least as fine as the\n    // one we're currently rendering.\n    // TODO: take into account that the histogramMeta chosen here might not\n    // fit neatly into the current histogram (e.g., if the current histogram\n    // is at 50,000 bases/bin, and we have server histograms at 20,000\n    // and 2,000 bases/bin, then we should choose the 2,000 histogramMeta\n    // rather than the 20,000)\n    let histogramMeta = data._histograms.meta[0]\n    for (let i = 0; i < data._histograms.meta.length; i += 1) {\n      if (basesPerBin >= data._histograms.meta[i].basesPerBin) {\n        histogramMeta = data._histograms.meta[i]\n      }\n    }\n\n    // number of bins in the server-supplied histogram for each current bin\n    let binRatio = basesPerBin / histogramMeta.basesPerBin\n\n    // if the server-supplied histogram fits neatly into our requested\n    if (binRatio > 0.9 && Math.abs(binRatio - Math.round(binRatio)) < 0.0001) {\n      // console.log('server-supplied',query);\n      // we can use the server-supplied counts\n      const firstServerBin = Math.floor(start / histogramMeta.basesPerBin)\n      binRatio = Math.round(binRatio)\n      const histogram = []\n      for (let bin = 0; bin < numBins; bin += 1) {\n        histogram[bin] = 0\n      }\n\n      for await (const [i, val] of histogramMeta.lazyArray.range(\n        firstServerBin,\n        firstServerBin + binRatio * numBins - 1,\n      )) {\n        // this will count features that span the boundaries of\n        // the original histogram multiple times, so it's not\n        // perfectly quantitative.  Hopefully it's still useful, though.\n        histogram[Math.floor((i - firstServerBin) / binRatio)] += val\n      }\n      return { bins: histogram, stats: statEntry }\n    }\n    // console.log('make own',query);\n    // make our own counts\n    const hist = await data.nclist.histogram(start, end, numBins)\n    return { bins: hist, stats: statEntry }\n  }\n\n  /**\n   * Fetch features in a given region. This method is an asynchronous generator\n   * yielding feature objects.\n   *\n   * @param {object} args\n   * @param {string} args.refName reference sequence name\n   * @param {number} args.start start of region. 0-based half-open.\n   * @param {number} args.end end of region. 0-based half-open.\n   * @yields {object}\n   */\n  async *getFeatures({ refName, start, end }) {\n    const data = await this.getDataRoot(refName)\n    const accessors = data.attrs && data.attrs.accessors()\n    for await (const [feature, path] of data.nclist.iterate(start, end)) {\n      // the unique ID is a stringification of the path in the\n      // NCList where the feature lives; it's unique across the\n      // top-level NCList (the top-level NCList covers a\n      // track/chromosome combination)\n\n      // only need to decorate a feature once\n      if (!feature.decorated) {\n        const uniqueID = path.join(',')\n        this.decorateFeature(accessors, feature, `${refName},${uniqueID}`)\n      }\n      yield feature\n    }\n  }\n\n  // helper method to recursively add .get and .tags methods to a feature and its\n  // subfeatures\n  decorateFeature(accessors, feature, id, parent) {\n    feature.get = accessors.get\n    feature.tags = accessors.tags\n    feature._uniqueID = id\n    feature.id = idfunc\n    feature._parent = parent\n    feature.parent = parentfunc\n    feature.children = childrenfunc\n    ;(feature.get('subfeatures') || []).forEach((f, i) => {\n      this.decorateFeature(accessors, f, `${id}-${i}`, feature)\n    })\n    feature.decorated = true\n  }\n}\n","//@ts-nocheck\nimport NCListStore from './feature_store'\n\nexport default NCListStore\n","import {\n  Feature,\n  SimpleFeatureSerialized,\n} from '@jbrowse/core/util/simpleFeature'\n\nconst jb2ToJb1 = { refName: 'seq_id' }\n\nconst jb1ToJb2 = { seq_id: 'refName' }\n\n/**\n * wrapper to adapt nclist features to act like jbrowse 2 features\n */\nexport default class NCListFeature implements Feature {\n  private parentHandle?: Feature\n\n  private uniqueId: string\n\n  constructor(\n    private ncFeature: any,\n    parent?: Feature,\n    id?: string,\n  ) {\n    this.uniqueId = id || ncFeature.id()\n    this.parentHandle = parent\n  }\n\n  set(): void {\n    throw new Error('not implemented')\n  }\n\n  jb2TagToJb1Tag(tag: string): string {\n    // @ts-expect-error\n    const mapped = jb2ToJb1[tag] || tag\n    return mapped.toLowerCase()\n  }\n\n  jb1TagToJb2Tag(tag: string): string {\n    const t = tag.toLowerCase()\n    // @ts-expect-error\n    return jb1ToJb2[t] || t\n  }\n\n  get(attrName: string): any {\n    const attr = this.ncFeature.get(this.jb2TagToJb1Tag(attrName))\n    if (attr && attrName === 'subfeatures') {\n      return attr.map((subfeature: any) => new NCListFeature(subfeature, this))\n    }\n    return attr\n  }\n\n  /**\n   * Get an array listing which data keys are present in this feature.\n   */\n  tags(): string[] {\n    return this.ncFeature.tags().map((t: string) => this.jb1TagToJb2Tag(t))\n  }\n\n  /**\n   * Get the unique ID of this feature.\n   */\n  id(): string {\n    return this.uniqueId\n  }\n\n  /**\n   * Get this feature's parent feature, or undefined if none.\n   */\n  parent(): Feature | undefined {\n    return this.parentHandle\n  }\n\n  /**\n   * Get an array of child features, or undefined if none.\n   */\n  children(): Feature[] | undefined {\n    return this.get('subfeatures')\n  }\n\n  toJSON(): SimpleFeatureSerialized {\n    // @ts-expect-error\n    const data: SimpleFeatureSerialized = { uniqueId: this.id() }\n\n    this.ncFeature.tags().forEach((tag: string) => {\n      const mappedTag = this.jb1TagToJb2Tag(tag)\n      const value = this.ncFeature.get(tag)\n      if (mappedTag === 'subfeatures') {\n        data.subfeatures = (value || []).map((f: Feature) => {\n          // note: was new NCListFeature(f, `${this.id()}-${i}`, this).toJSON()\n          return new NCListFeature(f, this).toJSON()\n        })\n      } else {\n        data[mappedTag] = value\n      }\n    })\n    return data\n  }\n}\n","import NCListStore from '@gmod/nclist'\nimport { Region } from '@jbrowse/core/util/types'\nimport {\n  BaseFeatureDataAdapter,\n  BaseOptions,\n} from '@jbrowse/core/data_adapters/BaseAdapter'\nimport { Feature } from '@jbrowse/core/util/simpleFeature'\nimport { ObservableCreate } from '@jbrowse/core/util/rxjs'\nimport { checkAbortSignal } from '@jbrowse/core/util'\nimport { RemoteFile } from 'generic-filehandle'\nimport NCListFeature from './NCListFeature'\nimport PluginManager from '@jbrowse/core/PluginManager'\nimport { getSubAdapterType } from '@jbrowse/core/data_adapters/dataAdapterCache'\nimport { AnyConfigurationModel } from '@jbrowse/core/configuration'\n\nexport default class NCListAdapter extends BaseFeatureDataAdapter {\n  private nclist: any\n\n  private configRefNames?: string[]\n\n  constructor(\n    config: AnyConfigurationModel,\n    getSubAdapter?: getSubAdapterType,\n    pluginManager?: PluginManager,\n  ) {\n    super(config, getSubAdapter, pluginManager)\n    const refNames = this.getConf('refNames')\n    const rootUrlTemplate = this.getConf('rootUrlTemplate')\n    this.configRefNames = refNames\n\n    this.nclist = new NCListStore({\n      baseUrl: '',\n      urlTemplate: rootUrlTemplate.uri,\n      readFile: (url: string) =>\n        new RemoteFile(\n          String(\n            rootUrlTemplate.baseUri\n              ? new URL(url, rootUrlTemplate.baseUri).toString()\n              : url,\n          ),\n        ).readFile(),\n    })\n  }\n\n  /**\n   * Fetch features for a certain region. Use getFeaturesInRegion() if you also\n   * want to verify that the store has features for the given reference sequence\n   * before fetching.\n   * @param region -\n   * @param opts - [signal] optional signalling object for aborting the fetch\n   * @returns Observable of Feature objects in the region\n   */\n  getFeatures(region: Region, opts: BaseOptions = {}) {\n    return ObservableCreate<Feature>(async observer => {\n      const { signal } = opts\n      for await (const feature of this.nclist.getFeatures(region, opts)) {\n        checkAbortSignal(signal)\n        observer.next(this.wrapFeature(feature))\n      }\n      observer.complete()\n    })\n  }\n\n  wrapFeature(ncFeature: any): NCListFeature {\n    return new NCListFeature(\n      ncFeature,\n      undefined,\n      `${this.id}-${ncFeature.id()}`,\n    )\n  }\n\n  async hasDataForRefName(refName: string) {\n    const root = await this.nclist.getDataRoot(refName)\n    return !!root?.stats?.featureCount\n  }\n\n  /**\n   * NCList is unable to get list of ref names so returns empty\n   */\n  async getRefNames() {\n    return this.configRefNames || []\n  }\n\n  /**\n   * called to provide a hint that data tied to a certain region\n   * will not be needed for the foreseeable future and can be purged\n   * from caches, etc\n   */\n  freeResources() {}\n}\n","class NullSignal {}\n\n/**\n * aggregates a number of abort signals, will only fire the aggregated\n * abort if all of the input signals have been aborted\n */\nexport default class AggregateAbortController {\n  signals = new Set()\n  abortController = new AbortController()\n\n  /**\n   * @param {AbortSignal} [signal] optional AbortSignal to add. if falsy,\n   *  will be treated as a null-signal, and this abortcontroller will no\n   *  longer be abortable.\n   */\n  //@ts-ignore\n  addSignal(signal: AbortSignal = new NullSignal()): void {\n    if (this.signal.aborted) {\n      throw new Error('cannot add a signal, already aborted!')\n    }\n\n    // note that a NullSignal will never fire, so if we\n    // have one this thing will never actually abort\n    this.signals.add(signal)\n    if (signal.aborted) {\n      // handle the abort immediately if it is already aborted\n      // for some reason\n      this.handleAborted(signal)\n    } else if (typeof signal.addEventListener === 'function') {\n      signal.addEventListener('abort', () => {\n        this.handleAborted(signal)\n      })\n    }\n  }\n\n  handleAborted(signal: AbortSignal): void {\n    this.signals.delete(signal)\n    if (this.signals.size === 0) {\n      this.abortController.abort()\n    }\n  }\n\n  get signal(): AbortSignal {\n    return this.abortController.signal\n  }\n\n  abort(): void {\n    this.abortController.abort()\n  }\n}\n","export default class AggregateStatusReporter {\n  callbacks = new Set<Function>()\n  currentMessage: unknown\n\n  addCallback(callback: Function = () => {}): void {\n    this.callbacks.add(callback)\n    callback(this.currentMessage)\n  }\n\n  callback(message: unknown) {\n    this.currentMessage = message\n    for (const elt of this.callbacks) {\n      elt(message)\n    }\n  }\n}\n","import AggregateAbortController from './AggregateAbortController'\nimport AggregateStatusReporter from './AggregateStatusReporter'\n\ninterface Cache<U> {\n  delete: (key: string) => void\n  keys: () => Iterator<string>\n  get: (key: string) => U | undefined\n  set: (key: string, value: U) => void\n  has: (key: string) => boolean\n}\ntype FillCallback<T, U> = (\n  data: T,\n  signal?: AbortSignal,\n  statusCallback?: Function,\n) => Promise<U>\n\ninterface Entry<U> {\n  aborter: AggregateAbortController\n  settled: boolean\n  readonly aborted: boolean\n  statusReporter: AggregateStatusReporter\n  promise: Promise<U>\n}\nexport default class AbortablePromiseCache<T, U> {\n  /**\n   * @param {object} args constructor args\n   * @param {Function} args.fill fill callback, will be called with sig `fill(data, signal)`\n   * @param {object} args.cache backing store to use, must implement `get(key)`, `set(key, val)`,\n   *   `delete(key)`, and `keys() -> iterator`\n   */\n\n  private cache: Cache<Entry<U>>\n  private fillCallback: FillCallback<T, U>\n\n  constructor({\n    fill,\n    cache,\n  }: {\n    fill: FillCallback<T, U>\n    cache: Cache<Entry<U>>\n  }) {\n    if (typeof fill !== 'function') {\n      throw new TypeError('must pass a fill function')\n    }\n    if (typeof cache !== 'object') {\n      throw new TypeError('must pass a cache object')\n    }\n    if (\n      typeof cache.get !== 'function' ||\n      typeof cache.set !== 'function' ||\n      typeof cache.delete !== 'function'\n    ) {\n      throw new TypeError(\n        'cache must implement get(key), set(key, val), and and delete(key)',\n      )\n    }\n\n    this.cache = cache\n    this.fillCallback = fill\n  }\n\n  static isAbortException(exception: Error) {\n    return (\n      // DOMException\n      exception.name === 'AbortError' ||\n      // standard-ish non-DOM abort exception\n      //@ts-ignore\n      exception.code === 'ERR_ABORTED' ||\n      // stringified DOMException\n      exception.message === 'AbortError: aborted' ||\n      // stringified standard-ish exception\n      exception.message === 'Error: aborted'\n    )\n  }\n\n  evict(key: string, entry: Entry<U>) {\n    if (this.cache.get(key) === entry) {\n      this.cache.delete(key)\n    }\n  }\n\n  fill(key: string, data: T, signal?: AbortSignal, statusCallback?: Function) {\n    const aborter = new AggregateAbortController()\n    const statusReporter = new AggregateStatusReporter()\n    statusReporter.addCallback(statusCallback)\n    const newEntry: Entry<U> = {\n      aborter: aborter,\n      promise: this.fillCallback(data, aborter.signal, (message: unknown) => {\n        statusReporter.callback(message)\n      }),\n      settled: false,\n      statusReporter,\n      get aborted() {\n        return this.aborter.signal.aborted\n      },\n    }\n    newEntry.aborter.addSignal(signal)\n\n    // remove the fill from the cache when its abortcontroller fires, if still in there\n    newEntry.aborter.signal.addEventListener('abort', () => {\n      if (!newEntry.settled) {\n        this.evict(key, newEntry)\n      }\n    })\n\n    // chain off the cached promise to record when it settles\n    newEntry.promise\n      .then(\n        () => {\n          newEntry.settled = true\n        },\n        () => {\n          newEntry.settled = true\n\n          // if the fill throws an error (including abort) and is still in the cache, remove it\n          this.evict(key, newEntry)\n        },\n      )\n      .catch(error => {\n        // this will only be reached if there is some kind of\n        // bad bug in this library\n        console.error(error)\n        throw error\n      })\n\n    this.cache.set(key, newEntry)\n  }\n\n  static checkSinglePromise<U>(promise: Promise<U>, signal?: AbortSignal) {\n    // check just this signal for having been aborted, and abort the\n    // promise if it was, regardless of what happened with the cached\n    // response\n    function checkForSingleAbort() {\n      if (signal?.aborted) {\n        throw Object.assign(new Error('aborted'), { code: 'ERR_ABORTED' })\n      }\n    }\n\n    return promise.then(\n      result => {\n        checkForSingleAbort()\n        return result\n      },\n      error => {\n        checkForSingleAbort()\n        throw error\n      },\n    )\n  }\n\n  has(key: string): boolean {\n    return this.cache.has(key)\n  }\n\n  /**\n   * Callback for getting status of the pending async\n   *\n   * @callback statusCallback\n   * @param {any} status, current status string or message object\n   */\n\n  /**\n   * @param {any} key cache key to use for this request\n   * @param {any} data data passed as the first argument to the fill callback\n   * @param {AbortSignal} [signal] optional AbortSignal object that aborts the request\n   * @param {statusCallback} a callback to get the current status of a pending async operation\n   */\n  get(\n    key: string,\n    data: T,\n    signal?: AbortSignal,\n    statusCallback?: Function,\n  ): Promise<U> {\n    if (!signal && data instanceof AbortSignal) {\n      throw new TypeError(\n        'second get argument appears to be an AbortSignal, perhaps you meant to pass `null` for the fill data?',\n      )\n    }\n    const cacheEntry = this.cache.get(key)\n\n    if (cacheEntry) {\n      if (cacheEntry.aborted && !cacheEntry.settled) {\n        // if it's aborted but has not realized it yet, evict it and redispatch\n        this.evict(key, cacheEntry)\n        return this.get(key, data, signal, statusCallback)\n      }\n\n      if (cacheEntry.settled) {\n        // too late to abort, just return it\n        return cacheEntry.promise\n      }\n\n      // request is in-flight, add this signal to its list of signals,\n      // or if there is no signal, the aborter will become non-abortable\n      cacheEntry.aborter.addSignal(signal)\n      cacheEntry.statusReporter.addCallback(statusCallback)\n\n      return AbortablePromiseCache.checkSinglePromise(\n        cacheEntry.promise,\n        signal,\n      )\n    }\n\n    // if we got here, it is not in the cache. fill.\n    this.fill(key, data, signal, statusCallback)\n    return AbortablePromiseCache.checkSinglePromise(\n      //see https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#non-null-assertion-operator-postfix-\n\n      this.cache.get(key)!.promise,\n      signal,\n    )\n  }\n\n  /**\n   * delete the given entry from the cache. if it exists and its fill request has\n   * not yet settled, the fill will be signaled to abort.\n   *\n   * @param {any} key\n   */\n  delete(key: string) {\n    const cachedEntry = this.cache.get(key)\n    if (cachedEntry) {\n      if (!cachedEntry.settled) {\n        cachedEntry.aborter.abort()\n      }\n      this.cache.delete(key)\n    }\n  }\n\n  /**\n   * Clear all requests from the cache. Aborts any that have not settled.\n   * @returns {number} count of entries deleted\n   */\n  clear() {\n    // iterate without needing regenerator-runtime\n    const keyIter = this.cache.keys()\n    let deleteCount = 0\n    for (let result = keyIter.next(); !result.done; result = keyIter.next()) {\n      this.delete(result.value)\n      deleteCount += 1\n    }\n    return deleteCount\n  }\n}\n","// Matches the scheme of a URL, eg \"http://\"\nconst schemeRegex = /^[\\w+.-]+:\\/\\//;\n\n/**\n * Matches the parts of a URL:\n * 1. Scheme, including \":\", guaranteed.\n * 2. User/password, including \"@\", optional.\n * 3. Host, guaranteed.\n * 4. Port, including \":\", optional.\n * 5. Path, including \"/\", optional.\n * 6. Query, including \"?\", optional.\n * 7. Hash, including \"#\", optional.\n */\nconst urlRegex = /^([\\w+.-]+:)\\/\\/([^@/#?]*@)?([^:/#?]*)(:\\d+)?(\\/[^#?]*)?(\\?[^#]*)?(#.*)?/;\n\n/**\n * File URLs are weird. They dont' need the regular `//` in the scheme, they may or may not start\n * with a leading `/`, they can have a domain (but only if they don't start with a Windows drive).\n *\n * 1. Host, optional.\n * 2. Path, which may include \"/\", guaranteed.\n * 3. Query, including \"?\", optional.\n * 4. Hash, including \"#\", optional.\n */\nconst fileRegex = /^file:(?:\\/\\/((?![a-z]:)[^/#?]*)?)?(\\/?[^#?]*)(\\?[^#]*)?(#.*)?/i;\n\ntype Url = {\n  scheme: string;\n  user: string;\n  host: string;\n  port: string;\n  path: string;\n  query: string;\n  hash: string;\n  type: UrlType;\n};\n\nconst enum UrlType {\n  Empty = 1,\n  Hash = 2,\n  Query = 3,\n  RelativePath = 4,\n  AbsolutePath = 5,\n  SchemeRelative = 6,\n  Absolute = 7,\n}\n\nfunction isAbsoluteUrl(input: string): boolean {\n  return schemeRegex.test(input);\n}\n\nfunction isSchemeRelativeUrl(input: string): boolean {\n  return input.startsWith('//');\n}\n\nfunction isAbsolutePath(input: string): boolean {\n  return input.startsWith('/');\n}\n\nfunction isFileUrl(input: string): boolean {\n  return input.startsWith('file:');\n}\n\nfunction isRelative(input: string): boolean {\n  return /^[.?#]/.test(input);\n}\n\nfunction parseAbsoluteUrl(input: string): Url {\n  const match = urlRegex.exec(input)!;\n  return makeUrl(\n    match[1],\n    match[2] || '',\n    match[3],\n    match[4] || '',\n    match[5] || '/',\n    match[6] || '',\n    match[7] || '',\n  );\n}\n\nfunction parseFileUrl(input: string): Url {\n  const match = fileRegex.exec(input)!;\n  const path = match[2];\n  return makeUrl(\n    'file:',\n    '',\n    match[1] || '',\n    '',\n    isAbsolutePath(path) ? path : '/' + path,\n    match[3] || '',\n    match[4] || '',\n  );\n}\n\nfunction makeUrl(\n  scheme: string,\n  user: string,\n  host: string,\n  port: string,\n  path: string,\n  query: string,\n  hash: string,\n): Url {\n  return {\n    scheme,\n    user,\n    host,\n    port,\n    path,\n    query,\n    hash,\n    type: UrlType.Absolute,\n  };\n}\n\nfunction parseUrl(input: string): Url {\n  if (isSchemeRelativeUrl(input)) {\n    const url = parseAbsoluteUrl('http:' + input);\n    url.scheme = '';\n    url.type = UrlType.SchemeRelative;\n    return url;\n  }\n\n  if (isAbsolutePath(input)) {\n    const url = parseAbsoluteUrl('http://foo.com' + input);\n    url.scheme = '';\n    url.host = '';\n    url.type = UrlType.AbsolutePath;\n    return url;\n  }\n\n  if (isFileUrl(input)) return parseFileUrl(input);\n\n  if (isAbsoluteUrl(input)) return parseAbsoluteUrl(input);\n\n  const url = parseAbsoluteUrl('http://foo.com/' + input);\n  url.scheme = '';\n  url.host = '';\n  url.type = input\n    ? input.startsWith('?')\n      ? UrlType.Query\n      : input.startsWith('#')\n      ? UrlType.Hash\n      : UrlType.RelativePath\n    : UrlType.Empty;\n  return url;\n}\n\nfunction stripPathFilename(path: string): string {\n  // If a path ends with a parent directory \"..\", then it's a relative path with excess parent\n  // paths. It's not a file, so we can't strip it.\n  if (path.endsWith('/..')) return path;\n  const index = path.lastIndexOf('/');\n  return path.slice(0, index + 1);\n}\n\nfunction mergePaths(url: Url, base: Url) {\n  normalizePath(base, base.type);\n\n  // If the path is just a \"/\", then it was an empty path to begin with (remember, we're a relative\n  // path).\n  if (url.path === '/') {\n    url.path = base.path;\n  } else {\n    // Resolution happens relative to the base path's directory, not the file.\n    url.path = stripPathFilename(base.path) + url.path;\n  }\n}\n\n/**\n * The path can have empty directories \"//\", unneeded parents \"foo/..\", or current directory\n * \"foo/.\". We need to normalize to a standard representation.\n */\nfunction normalizePath(url: Url, type: UrlType) {\n  const rel = type <= UrlType.RelativePath;\n  const pieces = url.path.split('/');\n\n  // We need to preserve the first piece always, so that we output a leading slash. The item at\n  // pieces[0] is an empty string.\n  let pointer = 1;\n\n  // Positive is the number of real directories we've output, used for popping a parent directory.\n  // Eg, \"foo/bar/..\" will have a positive 2, and we can decrement to be left with just \"foo\".\n  let positive = 0;\n\n  // We need to keep a trailing slash if we encounter an empty directory (eg, splitting \"foo/\" will\n  // generate `[\"foo\", \"\"]` pieces). And, if we pop a parent directory. But once we encounter a\n  // real directory, we won't need to append, unless the other conditions happen again.\n  let addTrailingSlash = false;\n\n  for (let i = 1; i < pieces.length; i++) {\n    const piece = pieces[i];\n\n    // An empty directory, could be a trailing slash, or just a double \"//\" in the path.\n    if (!piece) {\n      addTrailingSlash = true;\n      continue;\n    }\n\n    // If we encounter a real directory, then we don't need to append anymore.\n    addTrailingSlash = false;\n\n    // A current directory, which we can always drop.\n    if (piece === '.') continue;\n\n    // A parent directory, we need to see if there are any real directories we can pop. Else, we\n    // have an excess of parents, and we'll need to keep the \"..\".\n    if (piece === '..') {\n      if (positive) {\n        addTrailingSlash = true;\n        positive--;\n        pointer--;\n      } else if (rel) {\n        // If we're in a relativePath, then we need to keep the excess parents. Else, in an absolute\n        // URL, protocol relative URL, or an absolute path, we don't need to keep excess.\n        pieces[pointer++] = piece;\n      }\n      continue;\n    }\n\n    // We've encountered a real directory. Move it to the next insertion pointer, which accounts for\n    // any popped or dropped directories.\n    pieces[pointer++] = piece;\n    positive++;\n  }\n\n  let path = '';\n  for (let i = 1; i < pointer; i++) {\n    path += '/' + pieces[i];\n  }\n  if (!path || (addTrailingSlash && !path.endsWith('/..'))) {\n    path += '/';\n  }\n  url.path = path;\n}\n\n/**\n * Attempts to resolve `input` URL/path relative to `base`.\n */\nexport default function resolve(input: string, base: string | undefined): string {\n  if (!input && !base) return '';\n\n  const url = parseUrl(input);\n  let inputType = url.type;\n\n  if (base && inputType !== UrlType.Absolute) {\n    const baseUrl = parseUrl(base);\n    const baseType = baseUrl.type;\n\n    switch (inputType) {\n      case UrlType.Empty:\n        url.hash = baseUrl.hash;\n      // fall through\n\n      case UrlType.Hash:\n        url.query = baseUrl.query;\n      // fall through\n\n      case UrlType.Query:\n      case UrlType.RelativePath:\n        mergePaths(url, baseUrl);\n      // fall through\n\n      case UrlType.AbsolutePath:\n        // The host, user, and port are joined, you can't copy one without the others.\n        url.user = baseUrl.user;\n        url.host = baseUrl.host;\n        url.port = baseUrl.port;\n      // fall through\n\n      case UrlType.SchemeRelative:\n        // The input doesn't have a schema at least, so we need to copy at least that over.\n        url.scheme = baseUrl.scheme;\n    }\n    if (baseType > inputType) inputType = baseType;\n  }\n\n  normalizePath(url, inputType);\n\n  const queryHash = url.query + url.hash;\n  switch (inputType) {\n    // This is impossible, because of the empty checks at the start of the function.\n    // case UrlType.Empty:\n\n    case UrlType.Hash:\n    case UrlType.Query:\n      return queryHash;\n\n    case UrlType.RelativePath: {\n      // The first char is always a \"/\", and we need it to be relative.\n      const path = url.path.slice(1);\n\n      if (!path) return queryHash || '.';\n\n      if (isRelative(base || input) && !isRelative(path)) {\n        // If base started with a leading \".\", or there is no base and input started with a \".\",\n        // then we need to ensure that the relative path starts with a \".\". We don't know if\n        // relative starts with a \"..\", though, so check before prepending.\n        return './' + path + queryHash;\n      }\n\n      return path + queryHash;\n    }\n\n    case UrlType.AbsolutePath:\n      return url.path + queryHash;\n\n    default:\n      return url.scheme + '//' + url.user + url.host + url.port + url.path + queryHash;\n  }\n}\n"],"names":["async","readJSON","url","readFile","options","defaultContent","str","encoding","JSON","parse","error","code","status","message","includes","newURL","arg","base","NCList","constructor","cacheSize","this","topList","chunkCache","AbortablePromiseCache","A","cache","maxSize","fill","readChunkItems","bind","Error","importExisting","nclist","attrs","baseURL","lazyUrlTemplate","lazyClass","start","makeFastGetter","end","binarySearch","arr","item","getter","mid","low","high","length","chunkNum","replace","iterateSublist","from","to","inc","searchGet","testGet","path","getChunk","makeGetter","getSublist","pendingPromises","i","chunkItemsP","get","then","push","concat","sublist","iterate","histogram","numBins","result","Array","binWidth","feat","firstBin","Math","max","lastBin","min","bin","classes","fields","cl","f","attributes","undefined","proto","isArrayAttr","attrIndices","attr","map","x","indexOf","toLowerCase","obj","lcattr","adhocIndex","makeSetter","val","set","indices","accessors","_accessors","_makeAccessors","field","field_accessors","call","tags","forEach","cdef","classnum","attrname","offset","c","Object","keys","LazyArray","urlTemplate","chunkSize","baseUrl","index","callback","param","range","firstChunk","floor","lastChunk","chunkreadFiles","chunk","chunkNumber","chunkData","filterChunkData","queryStart","queryEnd","firstIndex","chunkStart","chunkEnd","idfunc","_uniqueID","parentfunc","_parent","childrenfunc","urlTemplates","root","dataRootCache","fetchDataRoot","makeNCList","loadNCList","refData","trackInfo","listUrl","intervals","getDataRoot","refName","parseTrackInfo","stats","featureCount","histograms","meta","lazyArray","arrayParams","_histograms","key","entry","key2","String","Number","getRegionStats","query","ref","getRegionFeatureDensities","basesPerBin","data","TypeError","ceil","statEntry","find","histogramMeta","binRatio","abs","round","firstServerBin","bins","getFeatures","feature","decorated","uniqueID","join","decorateFeature","id","parent","children","jb2ToJb1","jb1ToJb2","seq_id","NCListFeature","ncFeature","uniqueId","parentHandle","jb2TagToJb1Tag","tag","jb1TagToJb2Tag","t","attrName","subfeature","toJSON","mappedTag","value","subfeatures","NCListAdapter","BaseFeatureDataAdapter","config","getSubAdapter","pluginManager","super","refNames","getConf","rootUrlTemplate","configRefNames","NCListStore","uri","RemoteFile","baseUri","URL","toString","region","opts","ObservableCreate","signal","checkAbortSignal","observer","next","wrapFeature","complete","hasDataForRefName","getRefNames","freeResources","NullSignal","AggregateAbortController","signals","Set","abortController","AbortController","addSignal","aborted","add","handleAborted","addEventListener","delete","size","abort","AggregateStatusReporter","callbacks","addCallback","currentMessage","elt","fillCallback","isAbortException","exception","name","evict","statusCallback","aborter","statusReporter","newEntry","promise","settled","catch","console","checkSinglePromise","checkForSingleAbort","assign","has","AbortSignal","cacheEntry","cachedEntry","clear","keyIter","deleteCount","done","schemeRegex","urlRegex","fileRegex","isAbsolutePath","input","startsWith","isRelative","test","parseAbsoluteUrl","match","exec","makeUrl","scheme","user","host","port","hash","type","parseUrl","isSchemeRelativeUrl","isFileUrl","parseFileUrl","isAbsoluteUrl","normalizePath","rel","pieces","split","pointer","positive","addTrailingSlash","piece","endsWith","inputType","baseType","lastIndexOf","slice","stripPathFilename","mergePaths","queryHash"],"sourceRoot":""}