@gmod/tabix 3.1.0 → 3.1.2

package/src/csi.ts

@@ -58,7 +58,7 @@ export default class CSI extends IndexFile {
     const formatFlags = dataView.getInt32(offset, true)
     const coordinateType =
       formatFlags & 0x10000 ? 'zero-based-half-open' : '1-based-closed'
-    const format = formats[(formatFlags & 0xF) as 0 | 1 | 2]
+    const format = formats[(formatFlags & 0xf) as 0 | 1 | 2]
     if (!format) {
       throw new Error(`invalid Tabix preset format flags ${formatFlags}`)
     }
@@ -87,31 +87,6 @@ export default class CSI extends IndexFile {
     }
   }
 
-  _parseNameBytes(namesBytes: Uint8Array) {
-    let currRefId = 0
-    let currNameStart = 0
-    const refIdToName = []
-    const refNameToId: Record<string, number> = {}
-    const decoder = new TextDecoder('utf8')
-    for (let i = 0; i < namesBytes.length; i += 1) {
-      if (!namesBytes[i]) {
-        if (currNameStart < i) {
-          const refName = this.renameRefSeq(
-            decoder.decode(namesBytes.subarray(currNameStart, i)),
-          )
-          refIdToName[currRefId] = refName
-          refNameToId[refName] = currRefId
-        }
-        currNameStart = i + 1
-        currRefId += 1
-      }
-    }
-    return {
-      refNameToId,
-      refIdToName,
-    }
-  }
-
   async _parse(opts: Options = {}) {
     const bytes = await unzip(await this.filehandle.readFile(opts))
     const dataView = new DataView(bytes.buffer)

package/src/indexFile.ts

@@ -76,4 +76,29 @@ export default abstract class IndexFile {
     const idx = await this.parse(opts)
     return !!idx.indices[seqId]?.binIndex
   }
+
+  _parseNameBytes(namesBytes: Uint8Array) {
+    let currRefId = 0
+    let currNameStart = 0
+    const refIdToName: string[] = []
+    const refNameToId: Record<string, number> = {}
+    const decoder = new TextDecoder('utf8')
+    for (let i = 0; i < namesBytes.length; i += 1) {
+      if (!namesBytes[i]) {
+        if (currNameStart < i) {
+          const refName = this.renameRefSeq(
+            decoder.decode(namesBytes.subarray(currNameStart, i)),
+          )
+          refIdToName[currRefId] = refName
+          refNameToId[refName] = currRefId
+        }
+        currNameStart = i + 1
+        currRefId += 1
+      }
+    }
+    return {
+      refNameToId,
+      refIdToName,
+    }
+  }
 }

package/src/tabixIndexedFile.ts

@@ -11,11 +11,6 @@ import { checkAbortSignal } from './util.ts'
 
 import type { GenericFilehandle } from 'generic-filehandle2'
 
-function isASCII(str: string) {
-  // eslint-disable-next-line no-control-regex
-  return /^[\u0000-\u007F]*$/.test(str)
-}
-
 type GetLinesCallback = (line: string, fileOffset: number) => void
 
 interface GetLinesOpts {
@@ -164,6 +159,21 @@ export default class TabixIndexedFile {
    * @returns promise that is resolved when the whole read is finished,
    * rejected on error
    */
+  private calculateFileOffset(
+    cpositions: number[],
+    dpositions: number[],
+    pos: number,
+    blockStart: number,
+    minvDataPosition: number,
+  ) {
+    return (
+      cpositions[pos]! * (1 << 8) +
+      (blockStart - dpositions[pos]!) +
+      minvDataPosition +
+      1
+    )
+  }
+
   async getLines(
     refName: string,
     s: number | undefined,
@@ -212,69 +222,104 @@ export default class TabixIndexedFile {
       let pos = 0
 
       // fast path, Buffer is just ASCII chars and not gigantor, can be
-      // converted to string and processed directly. if it is not ASCII or
-      // gigantic (chrome max str len is 512Mb), we have to decode line by line
+      // converted to string and processed directly.
+      //
+      // if it is not ASCII or, we have to decode line by line, as it is
+      // otherwise hard to get the right 'fileOffset' based feature IDs
+      //
+      // we use a basic check for isASCII: string length equals buffer length
+      // if it is ASCII...no multi-byte decodings
       const str = decoder.decode(buffer)
-      const strIsASCII = isASCII(str)
-      while (blockStart < str.length) {
-        let line: string
-        let n: number
-        if (strIsASCII) {
-          n = str.indexOf('\n', blockStart)
+      const strIsASCII = buffer.length == str.length
+      if (strIsASCII) {
+        while (blockStart < str.length) {
+          const n = str.indexOf('\n', blockStart)
           if (n === -1) {
             break
           }
-          line = str.slice(blockStart, n)
-        } else {
-          n = buffer.indexOf('\n'.charCodeAt(0), blockStart)
+          const line = str.slice(blockStart, n)
+
+          // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+          if (dpositions) {
+            const target = blockStart + c.minv.dataPosition
+            while (pos < dpositions.length && target >= dpositions[pos]!) {
+              pos++
+            }
+          }
+
+          // filter the line for whether it is within the requested range
+          const { startCoordinate, overlaps } = this.checkLine(
+            metadata,
+            refName,
+            start,
+            end,
+            line,
+          )
+
+          if (overlaps) {
+            callback(
+              line,
+              this.calculateFileOffset(
+                cpositions,
+                dpositions,
+                pos,
+                blockStart,
+                c.minv.dataPosition,
+              ),
+            )
+          } else if (startCoordinate !== undefined && startCoordinate >= end) {
+            // the lines were overlapping the region, but now have stopped, so we
+            // must be at the end of the relevant data and we can stop processing
+            // data now
+            return
+          }
+          blockStart = n + 1
+        }
+      } else {
+        while (blockStart < buffer.length) {
+          const n = buffer.indexOf('\n'.charCodeAt(0), blockStart)
           if (n === -1) {
             break
           }
           const b = buffer.slice(blockStart, n)
-          line = decoder.decode(b)
-        }
+          const line = decoder.decode(b)
 
-        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-        if (dpositions) {
-          while (blockStart + c.minv.dataPosition >= dpositions[pos++]!) {}
-          pos--
-        }
+          // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+          if (dpositions) {
+            const target = blockStart + c.minv.dataPosition
+            while (pos < dpositions.length && target >= dpositions[pos]!) {
+              pos++
+            }
+          }
 
-        // filter the line for whether it is within the requested range
-        const { startCoordinate, overlaps } = this.checkLine(
-          metadata,
-          refName,
-          start,
-          end,
-          line,
-        )
-
-        if (overlaps) {
-          callback(
+          // filter the line for whether it is within the requested range
+          const { startCoordinate, overlaps } = this.checkLine(
+            metadata,
+            refName,
+            start,
+            end,
             line,
-            // cpositions[pos] refers to actual file offset of a bgzip block
-            // boundaries
-            //
-            // we multiply by (1 <<8) in order to make sure each block has a
-            // "unique" address space so that data in that block could never
-            // overlap
-            //
-            // then the blockStart-dpositions is an uncompressed file offset
-            // from that bgzip block boundary, and since the cpositions are
-            // multiplied by (1 << 8) these uncompressed offsets get a unique
-            // space
-            cpositions[pos]! * (1 << 8) +
-              (blockStart - dpositions[pos]!) +
-              c.minv.dataPosition +
-              1,
           )
-        } else if (startCoordinate !== undefined && startCoordinate >= end) {
-          // the lines were overlapping the region, but now have stopped, so we
-          // must be at the end of the relevant data and we can stop processing
-          // data now
-          return
+
+          if (overlaps) {
+            callback(
+              line,
+              this.calculateFileOffset(
+                cpositions,
+                dpositions,
+                pos,
+                blockStart,
+                c.minv.dataPosition,
+              ),
+            )
+          } else if (startCoordinate !== undefined && startCoordinate >= end) {
+            // the lines were overlapping the region, but now have stopped, so we
+            // must be at the end of the relevant data and we can stop processing
+            // data now
+            return
+          }
+          blockStart = n + 1
         }
-        blockStart = n + 1
       }
     }
   }
@@ -448,11 +493,11 @@ export default class TabixIndexedFile {
             }
           }
         }
-        currentColumnStart = i + 1
-        currentColumnNumber += 1
-        if (currentColumnNumber > maxColumn) {
+        if (currentColumnNumber === maxColumn) {
           break
         }
+        currentColumnStart = i + 1
+        currentColumnNumber += 1
       }
     }
     return {
@@ -470,17 +515,10 @@ export default class TabixIndexedFile {
     // be another pairwise feature at the end of this one
     const isTRA = info.includes('SVTYPE=TRA')
     if (info[0] !== '.' && !isTRA) {
-      let prevChar = ';'
-      for (let j = 0; j < info.length; j += 1) {
-        if (prevChar === ';' && info.slice(j, j + 4) === 'END=') {
-          let valueEnd = info.indexOf(';', j)
-          if (valueEnd === -1) {
-            valueEnd = info.length
-          }
-          endCoordinate = Number.parseInt(info.slice(j + 4, valueEnd), 10)
-          break
-        }
-        prevChar = info[j]
+      const endRegex = /(?:^|;)END=([^;]+)/
+      const match = endRegex.exec(info)
+      if (match) {
+        endCoordinate = Number.parseInt(match[1]!, 10)
       }
     } else if (isTRA) {
       return startCoordinate + 1

package/src/tbi.ts

@@ -62,7 +62,7 @@ export default class TabixIndex extends IndexFile {
       1: 'SAM',
       2: 'VCF',
     }
-    const format = formatOpts[formatFlags & 0xF]
+    const format = formatOpts[formatFlags & 0xf]
     if (!format) {
       throw new Error(`invalid Tabix preset format flags ${formatFlags}`)
     }
@@ -160,31 +160,6 @@ export default class TabixIndex extends IndexFile {
     }
   }
 
-  _parseNameBytes(namesBytes: Uint8Array) {
-    let currRefId = 0
-    let currNameStart = 0
-    const refIdToName: string[] = []
-    const refNameToId: Record<string, number> = {}
-    const decoder = new TextDecoder('utf8')
-    for (let i = 0; i < namesBytes.length; i += 1) {
-      if (!namesBytes[i]) {
-        if (currNameStart < i) {
-          const refName = this.renameRefSeq(
-            decoder.decode(namesBytes.subarray(currNameStart, i)),
-          )
-          refIdToName[currRefId] = refName
-          refNameToId[refName] = currRefId
-        }
-        currNameStart = i + 1
-        currRefId += 1
-      }
-    }
-    return {
-      refNameToId,
-      refIdToName,
-    }
-  }
-
   async blocksForRange(
     refName: string,
     min: number,