jbrowse-plugin-mafviewer 1.0.8 → 1.1.1

package/dist/parseNewick.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Newick format parser in JavaScript.
+ *
+ * Copyright (c) Jason Davies 2010.
+ *
+ * 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.
+ *
+ * Example tree (from http://en.wikipedia.org/wiki/Newick_format):
+ *
+ * +--0.1--A
+ * F-----0.2-----B            +-------0.3----C
+ * +------------------0.5-----E
+ *                            +---------0.4------D
+ *
+ * Newick format:
+ * (A:0.1,B:0.2,(C:0.3,D:0.4)E:0.5)F;
+ *
+ * Converted to JSON:
+ * {
+ *   name: "F",
+ *   children: [
+ *     {name: "A", length: 0.1},
+ *     {name: "B", length: 0.2},
+ *     {
+ *       name: "E",
+ *       length: 0.5,
+ *       children: [
+ *         {name: "C", length: 0.3},
+ *         {name: "D", length: 0.4}
+ *       ]
+ *     }
+ *   ]
+ * }
+ *
+ * Converted to JSON, but with no names or lengths:
+ * {
+ *   children: [
+ *     {}, {}, {
+ *       children: [{}, {}]
+ *     }
+ *   ]
+ * }
+ */
+export default function parseNewick(s: string): Record<string, any>;

package/dist/parseNewick.js

@@ -0,0 +1,95 @@
+/**
+ * Newick format parser in JavaScript.
+ *
+ * Copyright (c) Jason Davies 2010.
+ *
+ * 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.
+ *
+ * Example tree (from http://en.wikipedia.org/wiki/Newick_format):
+ *
+ * +--0.1--A
+ * F-----0.2-----B            +-------0.3----C
+ * +------------------0.5-----E
+ *                            +---------0.4------D
+ *
+ * Newick format:
+ * (A:0.1,B:0.2,(C:0.3,D:0.4)E:0.5)F;
+ *
+ * Converted to JSON:
+ * {
+ *   name: "F",
+ *   children: [
+ *     {name: "A", length: 0.1},
+ *     {name: "B", length: 0.2},
+ *     {
+ *       name: "E",
+ *       length: 0.5,
+ *       children: [
+ *         {name: "C", length: 0.3},
+ *         {name: "D", length: 0.4}
+ *       ]
+ *     }
+ *   ]
+ * }
+ *
+ * Converted to JSON, but with no names or lengths:
+ * {
+ *   children: [
+ *     {}, {}, {
+ *       children: [{}, {}]
+ *     }
+ *   ]
+ * }
+ */
+export default function parseNewick(s) {
+    const ancestors = [];
+    let tree = {};
+    const tokens = s.split(/\s*(;|\(|\)|,|:)\s*/);
+    for (let i = 0; i < tokens.length; i++) {
+        const token = tokens[i];
+        const subtree = {};
+        switch (token) {
+            case '(': // new children
+                tree.children = [subtree];
+                ancestors.push(tree);
+                tree = subtree;
+                break;
+            case ',': // another branch
+                ancestors.at(-1)?.children.push(subtree);
+                tree = subtree;
+                break;
+            case ')': // optional name next
+                tree = ancestors.pop();
+                break;
+            case ':': // optional length next
+                break;
+            default: {
+                const x = tokens[i - 1];
+                if (x === ')' || x === '(' || x === ',') {
+                    tree.name = token;
+                }
+                else if (x === ':') {
+                    tree.length = Number.parseFloat(token);
+                }
+            }
+        }
+    }
+    return tree;
+}
+//# sourceMappingURL=parseNewick.js.map

package/dist/parseNewick.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseNewick.js","sourceRoot":"","sources":["../src/parseNewick.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0DG;AACH,MAAM,CAAC,OAAO,UAAU,WAAW,CAAC,CAAS;IAC3C,MAAM,SAAS,GAAG,EAAE,CAAA;IAEpB,IAAI,IAAI,GAAG,EAAyB,CAAA;IACpC,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,qBAAqB,CAAC,CAAA;IAC7C,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QACvC,MAAM,KAAK,GAAG,MAAM,CAAC,CAAC,CAAE,CAAA;QACxB,MAAM,OAAO,GAAG,EAAE,CAAA;QAClB,QAAQ,KAAK,EAAE,CAAC;YACd,KAAK,GAAG,EAAE,eAAe;gBACvB,IAAI,CAAC,QAAQ,GAAG,CAAC,OAAO,CAAC,CAAA;gBACzB,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;gBACpB,IAAI,GAAG,OAAO,CAAA;gBACd,MAAK;YACP,KAAK,GAAG,EAAE,iBAAiB;gBACzB,SAAS,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,QAAQ,CAAC,IAAI,CAAC,OAAO,CAAC,CAAA;gBACxC,IAAI,GAAG,OAAO,CAAA;gBACd,MAAK;YACP,KAAK,GAAG,EAAE,qBAAqB;gBAC7B,IAAI,GAAG,SAAS,CAAC,GAAG,EAAG,CAAA;gBACvB,MAAK;YACP,KAAK,GAAG,EAAE,uBAAuB;gBAC/B,MAAK;YACP,OAAO,CAAC,CAAC,CAAC;gBACR,MAAM,CAAC,GAAG,MAAM,CAAC,CAAC,GAAG,CAAC,CAAE,CAAA;gBACxB,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK,GAAG,EAAE,CAAC;oBACxC,IAAI,CAAC,IAAI,GAAG,KAAK,CAAA;gBACnB,CAAC;qBAAM,IAAI,CAAC,KAAK,GAAG,EAAE,CAAC;oBACrB,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC,UAAU,CAAC,KAAK,CAAC,CAAA;gBACxC,CAAC;YACH,CAAC;QACH,CAAC;IACH,CAAC;IACD,OAAO,IAAI,CAAA;AACb,CAAC"}

package/dist/util.d.ts

@@ -0,0 +1,9 @@
+export declare function normalize(r: string[] | {
+    id: string;
+    label: string;
+    color?: string;
+}[]): {
+    id: string;
+    label: string;
+    color?: string;
+}[];

package/dist/util.js

@@ -0,0 +1,9 @@
+function isStrs(array) {
+    return typeof array[0] === 'string';
+}
+export function normalize(r) {
+    return isStrs(r)
+        ? r.map(elt => ({ id: elt, label: elt, color: undefined }))
+        : r;
+}
+//# sourceMappingURL=util.js.map

package/dist/util.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"util.js","sourceRoot":"","sources":["../src/util.ts"],"names":[],"mappings":"AAAA,SAAS,MAAM,CAAC,KAAgB;IAC9B,OAAO,OAAO,KAAK,CAAC,CAAC,CAAC,KAAK,QAAQ,CAAA;AACrC,CAAC;AAED,MAAM,UAAU,SAAS,CACvB,CAA6D;IAE7D,OAAO,MAAM,CAAC,CAAC,CAAC;QACd,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,EAAE,EAAE,EAAE,GAAG,EAAE,KAAK,EAAE,GAAG,EAAE,KAAK,EAAE,SAAS,EAAE,CAAC,CAAC;QAC3D,CAAC,CAAC,CAAC,CAAA;AACP,CAAC"}

package/package.json

@@ -1,5 +1,6 @@
 {
-  "version": "1.0.8",
+  "version": "1.1.1",
+  "license": "MIT",
   "name": "jbrowse-plugin-mafviewer",
   "keywords": [
     "jbrowse",
@@ -15,6 +16,7 @@
   "scripts": {
     "clean": "rimraf dist",
     "start": "node esbuild.mjs",
+    "format": "prettier --write .",
     "prebuild": "npm run clean",
     "build": "tsc && NODE_ENV=production node esbuild.mjs",
     "lint": "eslint --report-unused-disable-directives --max-warnings 0",
@@ -26,12 +28,14 @@
     "@babel/preset-react": "^7.10.4",
     "@emotion/react": "^11.10.4",
     "@fal-works/esbuild-plugin-global-externals": "^2.1.2",
-    "@jbrowse/core": "^2.6.1",
-    "@jbrowse/plugin-data-management": "^2.7.1",
-    "@jbrowse/plugin-linear-genome-view": "^2.7.1",
+    "@jbrowse/core": "^3.0.1",
+    "@jbrowse/plugin-data-management": "^3.0.1",
+    "@jbrowse/plugin-linear-genome-view": "^3.0.1",
     "@mui/material": "^6.2.0",
     "@mui/system": "^6.2.0",
     "@mui/x-data-grid": "^7.2.0",
+    "@types/d3-array": "^3.2.1",
+    "@types/d3-hierarchy": "^3.1.7",
     "@types/node": "^22.10.2",
     "@types/react": "^19.0.1",
     "@typescript-eslint/eslint-plugin": "^8.18.0",
@@ -39,12 +43,13 @@
     "chalk": "^5.3.0",
     "esbuild": "^0.24.0",
     "eslint": "^9.17.0",
+    "eslint-plugin-import": "^2.31.0",
     "eslint-plugin-react": "^7.20.3",
     "eslint-plugin-react-hooks": "^5.1.0",
     "eslint-plugin-unicorn": "^56.0.1",
     "mobx": "^6.0.0",
     "mobx-react": "^9.0.1",
-    "mobx-state-tree": "5.4.1",
+    "mobx-state-tree": "^5.4.1",
     "prettier": "^3.4.2",
     "pretty-bytes": "^6.1.1",
     "react": "^19.0.0",
@@ -55,5 +60,13 @@
     "tss-react": "^4.8.6",
     "typescript": "^5.1.6",
     "typescript-eslint": "^8.18.0"
+  },
+  "dependencies": {
+    "@gmod/bgzf-filehandle": "^2.0.4",
+    "buffer": "^6.0.3",
+    "d3-array": "^3.2.4",
+    "d3-hierarchy": "^3.1.2",
+    "generic-filehandle2": "^1.0.0",
+    "long": "^5.2.3"
   }
 }

package/src/BgzipTaffyAdapter/BgzipTaffyAdapter.ts

@@ -0,0 +1,227 @@
+import { unzip } from '@gmod/bgzf-filehandle'
+import { BaseFeatureDataAdapter } from '@jbrowse/core/data_adapters/BaseAdapter'
+import { Feature, Region, SimpleFeature } from '@jbrowse/core/util'
+import { openLocation } from '@jbrowse/core/util/io'
+import { ObservableCreate } from '@jbrowse/core/util/rxjs'
+import Long from 'long'
+
+import VirtualOffset from './virtualOffset'
+import parseNewick from '../parseNewick'
+import { normalize } from '../util'
+import { parseRowInstructions } from './rowInstructions'
+
+import type { IndexData, OrganismRecord } from './types'
+interface Entry {
+  type: string
+  row: number
+  asm: string
+  ref: string
+  start: number
+  strand: number
+  length: number
+}
+export default class BgzipTaffyAdapter extends BaseFeatureDataAdapter {
+  public setupP?: Promise<IndexData>
+
+  async getRefNames() {
+    const data = await this.setup()
+    return Object.keys(data)
+  }
+
+  setup() {
+    if (!this.setupP) {
+      this.setupP = this.readTaiFile().catch((e: unknown) => {
+        this.setupP = undefined
+        throw e
+      })
+    }
+    return this.setupP
+  }
+
+  async readTaiFile() {
+    const text = await openLocation(this.getConf('taiLocation')).readFile(
+      'utf8',
+    )
+    const lines = text
+      .split('\n')
+      .map(f => f.trim())
+      .filter(line => !!line)
+    const entries = {} as IndexData
+    let lastChr = ''
+    let lastChrStart = 0
+    let lastRawVirtualOffset = 0
+    for (const line of lines) {
+      const [chr, chrStart, virtualOffset] = line.split('\t')
+      const relativizedVirtualOffset = lastRawVirtualOffset + +virtualOffset!
+      const currChr = chr === '*' ? lastChr : chr!.split('.').at(-1)!
+
+      // bgzip TAF files store virtual offsets in plaintext in the TAI file
+      // these virtualoffsets are 64bit values, so the long library is needed
+      // to accurately do the bit manipulations needed
+      const x = Long.fromNumber(relativizedVirtualOffset)
+      const y = x.shiftRightUnsigned(16)
+      const z = x.and(0xffff)
+      const voff = new VirtualOffset(y.toNumber(), z.toNumber())
+
+      if (!entries[currChr]) {
+        entries[currChr] = []
+        lastChr = ''
+        lastChrStart = 0
+        lastRawVirtualOffset = 0
+      }
+      const currStart = +chrStart! + lastChrStart
+      entries[currChr].push({
+        chrStart: currStart,
+        virtualOffset: voff,
+      })
+      lastChr = currChr
+      lastChrStart = currStart
+      lastRawVirtualOffset = relativizedVirtualOffset
+    }
+    return entries
+  }
+
+  getFeatures(query: Region) {
+    return ObservableCreate<Feature>(async observer => {
+      try {
+        const lines = await this.getLines(query)
+        const alignments = {} as Record<string, OrganismRecord>
+
+        const k = lines.length
+        const data = [] as Entry[]
+        let a0: any
+        for (let j = 0; j < k; j++) {
+          const line = lines[j]!
+          if (line) {
+            const [lineData, rowInstructions] = line.split(' ; ')
+            if (rowInstructions) {
+              for (const ins of parseRowInstructions(rowInstructions)) {
+                if (ins.type === 'i') {
+                  data.splice(ins.row, 0, ins)
+                  if (!alignments[ins.asm]) {
+                    alignments[ins.asm] = {
+                      start: ins.start,
+                      strand: ins.strand,
+                      srcSize: ins.length,
+                      chr: ins.ref,
+                      data: '',
+                    }
+                  }
+                  const e = alignments[ins.asm]!
+                  e.data += ' '.repeat(Math.max(0, j - e.data.length)) // catch it up
+                } else if (ins.type === 's') {
+                  if (!alignments[ins.asm]) {
+                    alignments[ins.asm] = {
+                      start: ins.start,
+                      strand: ins.strand,
+                      srcSize: ins.length,
+                      chr: ins.ref,
+                      data: '',
+                    }
+                  }
+                  const e = alignments[ins.asm]!
+                  e.data += ' '.repeat(Math.max(0, j - e.data.length)) // catch it up
+                  data[ins.row] = ins
+                } else if (ins.type === 'd') {
+                  data.splice(ins.row, 1)
+                }
+
+                // no gaps for now(?)
+                // else if (ins.type === 'g') {
+                // }
+                // else if (ins.type === 'G') {
+                // }
+              }
+              if (!a0) {
+                a0 = data[0]
+              }
+            }
+            const lineLen = lineData!.length
+            for (let i = 0; i < lineLen; i++) {
+              const letter = lineData![i]
+              const r = data[i]!
+              alignments[r.asm]!.data += letter
+            }
+          }
+        }
+        if (a0) {
+          const row0 = alignments[a0.asm]!
+
+          // see
+          // https://github.com/ComparativeGenomicsToolkit/taffy/blob/f5a5354/docs/taffy_utilities.md#referenced-based-maftaf-and-indexing
+          // for the significance of row[0]:
+          //
+          // "An anchor line in TAF is a column from which all sequence
+          // coordinates can be deduced without scanning backwards to previous
+          // lines "
+          observer.next(
+            new SimpleFeature({
+              uniqueId: `${row0.start}-${row0.data.length}`,
+              refName: query.refName,
+              start: row0.start,
+              end: row0.start + row0.data.length,
+              strand: row0.strand,
+              alignments,
+              seq: row0.data,
+            }),
+          )
+        }
+        observer.complete()
+      } catch (e) {
+        observer.error(e)
+      }
+    })
+  }
+
+  async getSamples(_query: Region) {
+    const nhLoc = this.getConf('nhLocation')
+    const nh =
+      nhLoc.uri === '/path/to/my.nh'
+        ? undefined
+        : await openLocation(nhLoc).readFile('utf8')
+
+    // TODO: we may need to resolve the exact set of rows in the visible region
+    // here
+    return {
+      samples: normalize(this.getConf('samples')),
+      tree: nh ? parseNewick(nh) : undefined,
+    }
+  }
+
+  async getLines(query: Region) {
+    const byteRanges = await this.setup()
+    const file = openLocation(this.getConf('tafGzLocation'))
+
+    const decoder = new TextDecoder('utf8')
+    const records = byteRanges[query.refName]
+    if (records) {
+      let firstEntry = records[0]
+      let nextEntry
+      for (let i = 0; i < records.length; i++) {
+        if (records[i]!.chrStart >= query.start) {
+          // we use i-1 for firstEntry because the current record is "greater
+          // than the query start", we go backwards one record to make sure to
+          // cover up until the query start. we use i+1 to ensure we get at
+          // least one block in the case that i=0
+          firstEntry = records[Math.max(i - 1, 0)]
+          nextEntry = records[i + 1]
+          break
+        }
+      }
+      if (firstEntry && nextEntry) {
+        const response = await file.read(
+          nextEntry.virtualOffset.blockPosition -
+            firstEntry.virtualOffset.blockPosition,
+          firstEntry.virtualOffset.blockPosition,
+        )
+        const buffer = await unzip(response)
+        return decoder
+          .decode(buffer.slice(firstEntry.virtualOffset.dataPosition))
+          .split('\n')
+      }
+    }
+    return []
+  }
+
+  freeResources(): void {}
+}

package/src/{TaffyAdapter → BgzipTaffyAdapter}/configSchema.ts

@@ -1,13 +1,13 @@
 import { ConfigurationSchema } from '@jbrowse/core/configuration'
 
 /**
- * #config TaffyAdapter
- * used to configure Taffy adapter
+ * #config BgzipTaffyAdapter
+ * used to configure BgzipTaffy adapter
  */
 function x() {} // eslint-disable-line @typescript-eslint/no-unused-vars
 
 const configSchema = ConfigurationSchema(
-  'TaffyAdapter',
+  'BgzipTaffyAdapter',
   {
     /**
      * #slot
@@ -20,8 +20,9 @@ const configSchema = ConfigurationSchema(
     /**
      * #slot
      */
-    tafLocation: {
+    tafGzLocation: {
       type: 'fileLocation',
+      description: 'bgzip taffy file',
       defaultValue: {
         uri: '/path/to/my.taf',
         locationType: 'UriLocation',
@@ -32,13 +33,27 @@ const configSchema = ConfigurationSchema(
      */
     taiLocation: {
       type: 'fileLocation',
+      description: 'taffy index',
       defaultValue: {
-        uri: '/path/to/my.taf.tai',
+        uri: '/path/to/my.taf.gz.tai',
         locationType: 'UriLocation',
       },
     },
+    /**
+     * #slot
+     */
+    nhLocation: {
+      type: 'fileLocation',
+      description: 'newick tree',
+      defaultValue: {
+        uri: '/path/to/my.nh',
+        locationType: 'UriLocation',
+      },
+    },
+  },
+  {
+    explicitlyTyped: true,
   },
-  { explicitlyTyped: true },
 )
 
 export default configSchema

package/src/{TaffyAdapter → BgzipTaffyAdapter}/index.ts

@@ -1,14 +1,15 @@
 import PluginManager from '@jbrowse/core/PluginManager'
 import { AdapterType } from '@jbrowse/core/pluggableElementTypes'
+
+import BgzipTaffyAdapter from './BgzipTaffyAdapter'
 import configSchema from './configSchema'
-import TaffyAdapter from './TaffyAdapter'
 
-export default function TaffyAdapterF(pluginManager: PluginManager) {
+export default function BgzipTaffyAdapterF(pluginManager: PluginManager) {
   return pluginManager.addAdapterType(
     () =>
       new AdapterType({
-        name: 'TaffyAdapter',
-        AdapterClass: TaffyAdapter,
+        name: 'BgzipTaffyAdapter',
+        AdapterClass: BgzipTaffyAdapter,
         configSchema,
       }),
   )

package/src/BgzipTaffyAdapter/rowInstructions.ts

@@ -0,0 +1,91 @@
+interface RowInsert {
+  type: 'i'
+  row: number
+  asm: string
+  ref: string
+  start: number
+  strand: number
+  length: number
+}
+interface RowSubstitute {
+  type: 's'
+  row: number
+  asm: string
+  ref: string
+  start: number
+  strand: number
+  length: number
+}
+interface RowDelete {
+  type: 'd'
+  row: number
+}
+interface RowGap {
+  type: 'g'
+  row: number
+  gapLen: number
+}
+interface RowGapSubstring {
+  type: 'G'
+  row: number
+  gapSubstring: string
+}
+type RowInstruction =
+  | RowInsert
+  | RowDelete
+  | RowGap
+  | RowGapSubstring
+  | RowSubstitute
+
+export function parseRowInstructions(meta: string) {
+  const ret = meta.split(' ')
+  const rows = [] as RowInstruction[]
+
+  for (let i = 0; i < ret.length; ) {
+    const type = ret[i++]
+    if (type === 'i') {
+      const row = +ret[i++]!
+      const [asm, ref] = ret[i++]!.split('.')
+      rows.push({
+        type,
+        row,
+        asm: asm!,
+        ref: ref!,
+        start: +ret[i++]!,
+        strand: ret[i++] === '-' ? -1 : 1,
+        length: +ret[i++]!,
+      })
+    }
+    if (type === 's') {
+      const row = +ret[i++]!
+      const [asm, ref] = ret[i++]!.split('.')
+      rows.push({
+        type,
+        row,
+        asm: asm!,
+        ref: ref!,
+        start: +ret[i++]!,
+        strand: ret[i++] === '-' ? -1 : 1,
+        length: +ret[i++]!,
+      })
+    } else if (type === 'd') {
+      rows.push({
+        type,
+        row: +ret[i++]!,
+      })
+    } else if (type === 'g') {
+      rows.push({
+        type,
+        row: +ret[i++]!,
+        gapLen: +ret[i++]!,
+      })
+    } else if (type === 'G') {
+      rows.push({
+        type,
+        row: +ret[i++]!,
+        gapSubstring: ret[i++]!,
+      })
+    }
+  }
+  return rows
+}

package/src/BgzipTaffyAdapter/types.ts

@@ -0,0 +1,16 @@
+import VirtualOffset from './virtualOffset'
+
+export interface OrganismRecord {
+  chr: string
+  start: number
+  srcSize: number
+  strand: number
+  data: string
+}
+
+export interface ByteRange {
+  chrStart: number
+  virtualOffset: VirtualOffset
+}
+
+export type IndexData = Record<string, ByteRange[]>

package/src/BgzipTaffyAdapter/virtualOffset.ts

@@ -0,0 +1,29 @@
+export default class VirtualOffset {
+  public blockPosition: number
+  public dataPosition: number
+  constructor(blockPosition: number, dataPosition: number) {
+    this.blockPosition = blockPosition // < offset of the compressed data block
+    this.dataPosition = dataPosition // < offset into the uncompressed data
+  }
+
+  toString() {
+    return `${this.blockPosition}:${this.dataPosition}`
+  }
+
+  compareTo(b: VirtualOffset) {
+    return (
+      this.blockPosition - b.blockPosition || this.dataPosition - b.dataPosition
+    )
+  }
+}
+export function fromBytes(bytes: Uint8Array, offset = 0) {
+  return new VirtualOffset(
+    bytes[offset + 7]! * 0x10000000000 +
+      bytes[offset + 6]! * 0x100000000 +
+      bytes[offset + 5]! * 0x1000000 +
+      bytes[offset + 4]! * 0x10000 +
+      bytes[offset + 3]! * 0x100 +
+      bytes[offset + 2]!,
+    (bytes[offset + 1]! << 8) | bytes[offset]!,
+  )
+}