@jbrowse/core 4.3.0 → 5.0.0-beta.1

package/esm/util/flatbush/index.js

@@ -1,4 +1,9 @@
-import FlatQueue from "../flatqueue/index.js";
+// adapted from https://github.com/mourner/flatbush (ISC) by Colin Diesh
+//
+// JBrowse-local adaptations:
+// - TypeScript type annotations
+// - detached-ArrayBuffer check in `from` with a helpful error message (worker
+//   transferables leave buffers detached)
 const ARRAY_TYPES = [
     Int8Array,
     Uint8Array,
@@ -10,7 +15,7 @@ const ARRAY_TYPES = [
     Float32Array,
     Float64Array,
 ];
-const VERSION = 3;
+const VERSION = 3; // serialized format version
 export default class Flatbush {
     numItems;
     nodeSize;
@@ -26,11 +31,14 @@ export default class Flatbush {
     _boxes;
     _indices;
     _pos;
-    _queue;
+    /**
+     * Recreate a Flatbush index from raw `ArrayBuffer` data.
+     */
     static from(data, byteOffset = 0) {
         if (byteOffset % 8 !== 0) {
             throw new Error('byteOffset must be 8-byte aligned.');
         }
+        // Check for detached ArrayBuffer (happens if buffer was transferred)
         if (data.byteLength === 0) {
             throw new Error('Flatbush data buffer is detached (byteLength=0). ' +
                 'This usually means the buffer was transferred and is no longer usable.');
@@ -51,13 +59,18 @@ export default class Flatbush {
         const [numItems] = new Uint32Array(data, byteOffset + 4, 1);
         return new Flatbush(numItems, nodeSize, ArrayType, undefined, data, byteOffset);
     }
+    /**
+     * Create a Flatbush index that will hold a given number of items.
+     */
     constructor(numItems, nodeSize = 16, ArrayType = Float64Array, ArrayBufferType = ArrayBuffer, data, byteOffset = 0) {
-        if (isNaN(numItems) || numItems <= 0) {
+        if (Number.isNaN(numItems) || numItems <= 0) {
             throw new Error(`Unexpected numItems value: ${numItems}.`);
         }
         this.numItems = +numItems;
         this.nodeSize = Math.min(Math.max(+nodeSize, 2), 65535);
         this.byteOffset = byteOffset;
+        // calculate the total number of nodes in the R-tree to allocate space for
+        // and the index of each tree level (used in search later)
         let n = numItems;
         let numNodes = n;
         this._levelBounds = [n * 4];
@@ -96,16 +109,21 @@ export default class Flatbush {
             new Uint16Array(newData, 2, 1)[0] = nodeSize;
             new Uint32Array(newData, 4, 1)[0] = numItems;
         }
-        this._queue = new FlatQueue();
     }
+    /**
+     * Add a given rectangle to the index.
+     * @returns A zero-based, incremental number that represents the newly added rectangle.
+     */
     add(minX, minY, maxX = minX, maxY = minY) {
-        const index = this._pos >> 2;
+        const pos = this._pos;
+        const index = pos >> 2;
         const boxes = this._boxes;
         this._indices[index] = index;
-        boxes[this._pos++] = minX;
-        boxes[this._pos++] = minY;
-        boxes[this._pos++] = maxX;
-        boxes[this._pos++] = maxY;
+        boxes[pos] = minX;
+        boxes[pos + 1] = minY;
+        boxes[pos + 2] = maxX;
+        boxes[pos + 3] = maxY;
+        this._pos = pos + 4;
         if (minX < this.minX) {
             this.minX = minX;
         }
@@ -120,195 +138,187 @@ export default class Flatbush {
         }
         return index;
     }
+    /** Perform indexing of the added rectangles. */
     finish() {
         if (this._pos >> 2 !== this.numItems) {
             throw new Error(`Added ${this._pos >> 2} items when expected ${this.numItems}.`);
         }
         const boxes = this._boxes;
         if (this.numItems <= this.nodeSize) {
+            // only one node, skip sorting and just fill the root box
             boxes[this._pos++] = this.minX;
             boxes[this._pos++] = this.minY;
             boxes[this._pos++] = this.maxX;
             boxes[this._pos++] = this.maxY;
             return;
         }
-        const width = this.maxX - this.minX || 1;
-        const height = this.maxY - this.minY || 1;
-        const hilbertValues = new Uint32Array(this.numItems);
+        const numItems = this.numItems;
+        const minX = this.minX;
+        const minY = this.minY;
+        const nodeSize = this.nodeSize;
+        const indices = this._indices;
+        const levelBounds = this._levelBounds;
+        const width = this.maxX - minX || 1;
+        const height = this.maxY - minY || 1;
+        const hilbertValues = new Int32Array(numItems);
         const hilbertMax = (1 << 16) - 1;
-        const scaleX = hilbertMax / width;
-        const scaleY = hilbertMax / height;
-        const offsetX = this.minX;
-        const offsetY = this.minY;
-        for (let i = 0, pos = 0; i < this.numItems; i++) {
-            const minX = boxes[pos++];
-            const minY = boxes[pos++];
-            const maxX = boxes[pos++];
-            const maxY = boxes[pos++];
-            const x = Math.floor(((minX + maxX) * 0.5 - offsetX) * scaleX);
-            const y = Math.floor(((minY + maxY) * 0.5 - offsetY) * scaleY);
+        const sx = hilbertMax / width;
+        const sy = hilbertMax / height;
+        // map item centers into Hilbert coordinate space and calculate Hilbert values
+        for (let i = 0, pos = 0; i < numItems; i++) {
+            const itemMinX = boxes[pos++];
+            const itemMinY = boxes[pos++];
+            const itemMaxX = boxes[pos++];
+            const itemMaxY = boxes[pos++];
+            const x = (sx * ((itemMinX + itemMaxX) / 2 - minX)) | 0;
+            const y = (sy * ((itemMinY + itemMaxY) / 2 - minY)) | 0;
             hilbertValues[i] = hilbert(x, y);
         }
-        sort(hilbertValues, boxes, this._indices, 0, this.numItems - 1, this.nodeSize);
-        for (let i = 0, pos = 0; i < this._levelBounds.length - 1; i++) {
-            const end = this._levelBounds[i];
-            while (pos < end) {
-                const nodeIndex = pos;
-                let nodeMinX = boxes[pos++];
-                let nodeMinY = boxes[pos++];
-                let nodeMaxX = boxes[pos++];
-                let nodeMaxY = boxes[pos++];
-                for (let j = 1; j < this.nodeSize && pos < end; j++) {
-                    const x0 = boxes[pos++];
-                    const y0 = boxes[pos++];
-                    const x1 = boxes[pos++];
-                    const y1 = boxes[pos++];
-                    if (x0 < nodeMinX) {
-                        nodeMinX = x0;
-                    }
-                    if (y0 < nodeMinY) {
-                        nodeMinY = y0;
-                    }
-                    if (x1 > nodeMaxX) {
-                        nodeMaxX = x1;
-                    }
-                    if (y1 > nodeMaxY) {
-                        nodeMaxY = y1;
-                    }
+        // sort items by their Hilbert value (for packing later)
+        sort(hilbertValues, boxes, indices, 0, numItems - 1, nodeSize);
+        // generate nodes at each tree level, bottom-up
+        let pos = numItems * 4;
+        for (let i = 0, readPos = 0; i < levelBounds.length - 1; i++) {
+            const end = levelBounds[i];
+            // generate a parent node for each block of consecutive <nodeSize> nodes
+            while (readPos < end) {
+                const nodeIndex = readPos;
+                // calculate bbox for the new node
+                let nodeMinX = boxes[readPos++];
+                let nodeMinY = boxes[readPos++];
+                let nodeMaxX = boxes[readPos++];
+                let nodeMaxY = boxes[readPos++];
+                for (let j = 1; j < nodeSize && readPos < end; j++) {
+                    nodeMinX = Math.min(nodeMinX, boxes[readPos++]);
+                    nodeMinY = Math.min(nodeMinY, boxes[readPos++]);
+                    nodeMaxX = Math.max(nodeMaxX, boxes[readPos++]);
+                    nodeMaxY = Math.max(nodeMaxY, boxes[readPos++]);
                 }
-                this._indices[this._pos >> 2] = nodeIndex;
-                boxes[this._pos++] = nodeMinX;
-                boxes[this._pos++] = nodeMinY;
-                boxes[this._pos++] = nodeMaxX;
-                boxes[this._pos++] = nodeMaxY;
+                // add the new node to the tree data
+                indices[pos >> 2] = nodeIndex;
+                boxes[pos++] = nodeMinX;
+                boxes[pos++] = nodeMinY;
+                boxes[pos++] = nodeMaxX;
+                boxes[pos++] = nodeMaxY;
             }
         }
+        this._pos = pos;
     }
+    /**
+     * Search the index by a bounding box.
+     * @param filterFn An optional function that is called on every found item; if supplied, only items for which this function returns true will be included in the results array.
+     * @returns An array of indices of items intersecting or touching the given bounding box.
+     */
     search(minX, minY, maxX, maxY, filterFn) {
         if (this._pos !== this._boxes.length) {
             throw new Error('Data not yet indexed - call index.finish().');
         }
-        let nodeIndex = this._boxes.length - 4;
-        const queue = [];
+        const boxes = this._boxes;
+        const levelBounds = this._levelBounds;
+        const indices = this._indices;
+        const nodeSize = this.nodeSize;
+        const numItems4 = this.numItems * 4;
+        let nodeIndex = boxes.length - 4;
+        let level = levelBounds.length - 1; // start at the root level
+        const q = [];
         const results = [];
+        let contained = false; // whether the current node's bbox is fully inside the query
         while (nodeIndex !== undefined) {
-            const end = Math.min(nodeIndex + this.nodeSize * 4, upperBound(nodeIndex, this._levelBounds));
-            for (let pos = nodeIndex; pos < end; pos += 4) {
-                const x0 = this._boxes[pos];
-                if (maxX < x0) {
-                    continue;
-                }
-                const y0 = this._boxes[pos + 1];
-                if (maxY < y0) {
-                    continue;
-                }
-                const x1 = this._boxes[pos + 2];
-                if (minX > x1) {
-                    continue;
-                }
-                const y1 = this._boxes[pos + 3];
-                if (minY > y1) {
-                    continue;
-                }
-                const index = this._indices[pos >> 2] | 0;
-                if (nodeIndex >= this.numItems * 4) {
-                    queue.push(index);
-                }
-                else if (filterFn === undefined || filterFn(index, x0, y0, x1, y1)) {
-                    results.push(index);
-                }
+            // find the end index of the node, capped at the level boundary
+            const end = Math.min(nodeIndex + nodeSize * 4, levelBounds[level]);
+            const isNode = nodeIndex >= numItems4;
+            if (contained) {
+                this._collectContained(nodeIndex, end, level, numItems4, results, filterFn);
             }
-            nodeIndex = queue.pop();
-        }
-        return results;
-    }
-    neighbors(x, y, maxResults = Infinity, maxDistance = Infinity, filterFn) {
-        if (this._pos !== this._boxes.length) {
-            throw new Error('Data not yet indexed - call index.finish().');
-        }
-        let nodeIndex = this._boxes.length - 4;
-        const q = this._queue;
-        const results = [];
-        const maxDistSquared = maxDistance * maxDistance;
-        outer: while (nodeIndex !== undefined) {
-            const end = Math.min(nodeIndex + this.nodeSize * 4, upperBound(nodeIndex, this._levelBounds));
-            for (let pos = nodeIndex; pos < end; pos += 4) {
-                const index = this._indices[pos >> 2] | 0;
-                const minX = this._boxes[pos];
-                const minY = this._boxes[pos + 1];
-                const maxX = this._boxes[pos + 2];
-                const maxY = this._boxes[pos + 3];
-                const dx = x < minX ? minX - x : x > maxX ? x - maxX : 0;
-                const dy = y < minY ? minY - y : y > maxY ? y - maxY : 0;
-                const dist = dx * dx + dy * dy;
-                if (dist > maxDistSquared) {
-                    continue;
-                }
-                if (nodeIndex >= this.numItems * 4) {
-                    q.push(index << 1, dist);
-                }
-                else if (filterFn === undefined || filterFn(index)) {
-                    q.push((index << 1) + 1, dist);
+            else {
+                // search through child nodes
+                for (let pos = nodeIndex; pos < end; pos += 4) {
+                    // check if node bbox intersects with query bbox
+                    const x0 = boxes[pos];
+                    if (maxX < x0) {
+                        continue;
+                    }
+                    const y0 = boxes[pos + 1];
+                    if (maxY < y0) {
+                        continue;
+                    }
+                    const x1 = boxes[pos + 2];
+                    if (minX > x1) {
+                        continue;
+                    }
+                    const y1 = boxes[pos + 3];
+                    if (minY > y1) {
+                        continue;
+                    }
+                    const index = indices[pos >> 2] | 0;
+                    if (isNode) {
+                        // node intersects; flag it as contained if its bbox is fully inside the query
+                        const c = +(minX <= x0 && minY <= y0 && maxX >= x1 && maxY >= y1);
+                        q.push(index | c, level - 1); // node; add it and its level to the search queue
+                    }
+                    else if (filterFn === undefined ||
+                        filterFn(index, x0, y0, x1, y1)) {
+                        results.push(index); // leaf item
+                    }
                 }
             }
-            while (q.length && q.peek() & 1) {
-                const dist = q.peekValue();
-                if (dist > maxDistSquared) {
-                    break outer;
-                }
-                results.push(q.pop() >> 1);
-                if (results.length === maxResults) {
-                    break outer;
-                }
+            const poppedLevel = q.pop();
+            nodeIndex = q.pop();
+            if (nodeIndex !== undefined) {
+                level = poppedLevel;
+                contained = (nodeIndex & 1) === 1;
+                nodeIndex &= ~1;
             }
-            nodeIndex = q.length ? q.pop() >> 1 : undefined;
         }
-        q.clear();
         return results;
     }
-}
-function upperBound(value, arr) {
-    let i = 0;
-    let j = arr.length - 1;
-    while (i < j) {
-        const m = (i + j) >> 1;
-        if (arr[m] > value) {
-            j = m;
+    /**
+     * Collect all leaves of a subtree that's fully inside the query, skipping intersection tests.
+     * Because the tree is packed bottom-up, those leaves occupy one contiguous block of the leaf
+     * level, so we skip traversal entirely: descend to the first leaf, then sweep the flat range.
+     */
+    _collectContained(nodeIndex, end, level, numItems4, results, filterFn) {
+        const boxes = this._boxes;
+        const indices = this._indices;
+        let pos = nodeIndex;
+        for (let l = level; l > 0; l--) {
+            pos = indices[pos >> 2];
+        }
+        const leafEnd = Math.min(pos + (end - nodeIndex) * this.nodeSize ** level, numItems4);
+        if (filterFn === undefined) {
+            for (; pos < leafEnd; pos += 4) {
+                results.push(indices[pos >> 2] | 0);
+            }
         }
         else {
-            i = m + 1;
+            for (; pos < leafEnd; pos += 4) {
+                const index = indices[pos >> 2] | 0;
+                if (filterFn(index, boxes[pos], boxes[pos + 1], boxes[pos + 2], boxes[pos + 3])) {
+                    results.push(index);
+                }
+            }
         }
     }
-    return arr[i];
 }
+/**
+ * Custom quicksort that partially sorts bbox data alongside the hilbert values.
+ */
 function sort(values, boxes, indices, left, right, nodeSize) {
     const stack = [left, right];
     while (stack.length > 0) {
         const r = stack.pop();
         const l = stack.pop();
-        if (Math.floor(l / nodeSize) >= Math.floor(r / nodeSize)) {
+        if (r - l <= nodeSize &&
+            Math.floor(l / nodeSize) >= Math.floor(r / nodeSize)) {
             continue;
         }
-        if (r - l < 10) {
-            insertionSort(values, boxes, indices, l, r);
-            continue;
-        }
-        const start = values[l];
-        const mid = values[(l + r) >> 1];
-        const end = values[r];
-        let pivot = end;
-        const x = Math.max(start, mid);
-        if (end > x) {
-            pivot = x;
-        }
-        else if (x === start) {
-            pivot = Math.max(mid, end);
-        }
-        else if (x === mid) {
-            pivot = Math.max(start, end);
-        }
+        const a = values[l];
+        const b = values[(l + r) >> 1];
+        const c = values[r];
+        const pivot = a > b !== a > c ? a : b < a !== b < c ? b : c;
         let i = l - 1;
         let j = r + 1;
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
         while (true) {
             do {
                 i++;
@@ -324,36 +334,9 @@ function sort(values, boxes, indices, left, right, nodeSize) {
         stack.push(l, j, j + 1, r);
     }
 }
-function insertionSort(values, boxes, indices, left, right) {
-    for (let i = left + 1; i <= right; i++) {
-        const tempVal = values[i];
-        const tempIdx = indices[i];
-        const k = i * 4;
-        const tempA = boxes[k];
-        const tempB = boxes[k + 1];
-        const tempC = boxes[k + 2];
-        const tempD = boxes[k + 3];
-        let j = i - 1;
-        while (j >= left && values[j] > tempVal) {
-            values[j + 1] = values[j];
-            indices[j + 1] = indices[j];
-            const src = j * 4;
-            const dst = (j + 1) * 4;
-            boxes[dst] = boxes[src];
-            boxes[dst + 1] = boxes[src + 1];
-            boxes[dst + 2] = boxes[src + 2];
-            boxes[dst + 3] = boxes[src + 3];
-            j--;
-        }
-        values[j + 1] = tempVal;
-        indices[j + 1] = tempIdx;
-        const dst = (j + 1) * 4;
-        boxes[dst] = tempA;
-        boxes[dst + 1] = tempB;
-        boxes[dst + 2] = tempC;
-        boxes[dst + 3] = tempD;
-    }
-}
+/**
+ * Swap two values and two corresponding boxes.
+ */
 function swap(values, boxes, indices, i, j) {
     const temp = values[i];
     values[i] = values[j];
@@ -376,6 +359,10 @@ function swap(values, boxes, indices, i, j) {
     indices[i] = indices[j];
     indices[j] = e;
 }
+/**
+ * Fast Hilbert curve algorithm by https://threadlocalmutex.com/
+ * Ported from C++ https://github.com/rawrunprotected/hilbert_curves (public domain)
+ */
 function hilbert(x, y) {
     let a = x ^ y;
     let b = 0xffff ^ a;
@@ -383,41 +370,30 @@ function hilbert(x, y) {
     let d = x & (y ^ 0xffff);
     let A = a | (b >> 1);
     let B = (a >> 1) ^ a;
-    let C = (c >> 1) ^ (b & (d >> 1)) ^ c;
-    let D = (a & (c >> 1)) ^ (d >> 1) ^ d;
-    a = A;
-    b = B;
-    c = C;
-    d = D;
-    A = (a & (a >> 2)) ^ (b & (b >> 2));
-    B = (a & (b >> 2)) ^ (b & ((a ^ b) >> 2));
-    C ^= (a & (c >> 2)) ^ (b & (d >> 2));
-    D ^= (b & (c >> 2)) ^ ((a ^ b) & (d >> 2));
-    a = A;
-    b = B;
-    c = C;
-    d = D;
+    let C = c ^ ((c >> 1) ^ (b & (d >> 1)));
+    let D = d ^ ((a & (c >> 1)) ^ (d >> 1));
+    a = (A & (A >> 2)) ^ (B & (B >> 2));
+    b = (A & (B >> 2)) ^ (B & ((A ^ B) >> 2));
+    c = C ^ ((A & (C >> 2)) ^ (B & (D >> 2)));
+    d = D ^ ((B & (C >> 2)) ^ ((A ^ B) & (D >> 2)));
     A = (a & (a >> 4)) ^ (b & (b >> 4));
     B = (a & (b >> 4)) ^ (b & ((a ^ b) >> 4));
-    C ^= (a & (c >> 4)) ^ (b & (d >> 4));
-    D ^= (b & (c >> 4)) ^ ((a ^ b) & (d >> 4));
-    a = A;
-    b = B;
-    c = C;
-    d = D;
-    C ^= (a & (c >> 8)) ^ (b & (d >> 8));
-    D ^= (b & (c >> 8)) ^ ((a ^ b) & (d >> 8));
-    a = C ^ (C >> 1);
-    b = D ^ (D >> 1);
-    let i0 = x ^ y;
-    let i1 = b | (0xffff ^ (i0 | a));
-    i0 = (i0 | (i0 << 8)) & 0x00ff00ff;
-    i0 = (i0 | (i0 << 4)) & 0x0f0f0f0f;
-    i0 = (i0 | (i0 << 2)) & 0x33333333;
-    i0 = (i0 | (i0 << 1)) & 0x55555555;
-    i1 = (i1 | (i1 << 8)) & 0x00ff00ff;
-    i1 = (i1 | (i1 << 4)) & 0x0f0f0f0f;
-    i1 = (i1 | (i1 << 2)) & 0x33333333;
-    i1 = (i1 | (i1 << 1)) & 0x55555555;
-    return ((i1 << 1) | i0) >>> 0;
+    C = c ^ ((a & (c >> 4)) ^ (b & (d >> 4)));
+    D = d ^ ((b & (c >> 4)) ^ ((a ^ b) & (d >> 4)));
+    c = C ^ ((A & (C >> 8)) ^ (B & (D >> 8)));
+    d = D ^ ((B & (C >> 8)) ^ ((A ^ B) & (D >> 8)));
+    c ^= c >> 1;
+    d ^= d >> 1;
+    a = x ^ y;
+    b = d | (0xffff ^ (a | c));
+    a = (a | (a << 8)) & 0x00ff00ff;
+    a = (a | (a << 4)) & 0x0f0f0f0f;
+    a = (a | (a << 2)) & 0x33333333;
+    a = (a | (a << 1)) & 0x55555555;
+    b = (b | (b << 8)) & 0x00ff00ff;
+    b = (b | (b << 4)) & 0x0f0f0f0f;
+    b = (b | (b << 2)) & 0x33333333;
+    b = (b | (b << 1)) & 0x55555555;
+    // shift into signed SMI range for performance
+    return (((b << 1) | a) >>> 0) - 0x80000000;
 }

package/esm/util/formatBytes.d.ts

@@ -0,0 +1,9 @@
+/**
+ * A byte count for a human, in SI units — 1 kB is 1000 bytes, which is what the
+ * unit means and what a file manager reports. The two hand-rolled copies this
+ * replaced disagreed: one was SI, the other divided by 1024 and labelled the
+ * result "KB", so it read ~2.4% low by the third step and called a KiB a kB.
+ *
+ * Whole bytes stay whole; every step above gets one decimal.
+ */
+export declare function formatBytes(bytes: number): string;

package/esm/util/formatBytes.js

@@ -0,0 +1,18 @@
+const units = ['bytes', 'kB', 'MB', 'GB', 'TB'];
+/**
+ * A byte count for a human, in SI units — 1 kB is 1000 bytes, which is what the
+ * unit means and what a file manager reports. The two hand-rolled copies this
+ * replaced disagreed: one was SI, the other divided by 1024 and labelled the
+ * result "KB", so it read ~2.4% low by the third step and called a KiB a kB.
+ *
+ * Whole bytes stay whole; every step above gets one decimal.
+ */
+export function formatBytes(bytes) {
+    let n = bytes;
+    let i = 0;
+    while (n >= 1000 && i < units.length - 1) {
+        n /= 1000;
+        i++;
+    }
+    return `${i === 0 ? n : n.toFixed(1)} ${units[i]}`;
+}

package/esm/util/formatFastaStrings.d.ts

@@ -2,5 +2,18 @@ export interface SeqChunk {
     header: string;
     seq: string;
 }
+/**
+ * Returns sequence with new line every 80 characters
+ * ref https://stackoverflow.com/a/51506718/2129219
+ *
+ * @param seqString -  string
+ * @returns formatted sequence string
+ */
 export declare function formatFastaLines(seqString: string): string;
+/**
+ * Formats the sequences chunks into Fasta format
+ *
+ * @param chunks - array of seq chunks of the form `{ header: string, seq: string }`
+ * @returns formatted sequence in fasta format
+ */
 export declare function formatSeqFasta(chunks: SeqChunk[]): string;

package/esm/util/formatFastaStrings.js

@@ -1,6 +1,19 @@
+/**
+ * Returns sequence with new line every 80 characters
+ * ref https://stackoverflow.com/a/51506718/2129219
+ *
+ * @param seqString -  string
+ * @returns formatted sequence string
+ */
 export function formatFastaLines(seqString) {
     return seqString.replaceAll(/(.{1,80})/g, '$1\n').trimEnd();
 }
+/**
+ * Formats the sequences chunks into Fasta format
+ *
+ * @param chunks - array of seq chunks of the form `{ header: string, seq: string }`
+ * @returns formatted sequence in fasta format
+ */
 export function formatSeqFasta(chunks) {
     return chunks
         .map(chunk => `>${chunk.header}\n${formatFastaLines(chunk.seq)}`)

package/esm/util/formatGuessers.d.ts

@@ -0,0 +1,30 @@
+import type PluginManager from '../PluginManager.ts';
+import type { AdapterConfig } from './tracks.ts';
+import type { FileLocation } from './types/data.ts';
+import type { AdapterSpec } from '@jbrowse/add-track-core';
+/**
+ * The adapter config one format-table entry describes: the data file under the
+ * field that format's adapter reads it from, plus wherever that adapter expects
+ * its index — nested under `index` for BAM and the tabix formats, a top-level
+ * sidecar field for CRAM and FASTA.
+ *
+ * `index` is the location the caller was handed (the "index file" field of the
+ * add-track form); every sidecar the caller did not name is derived from the
+ * data file's own location.
+ */
+export declare function adapterConfigFromSpec(spec: AdapterSpec, file: FileLocation, index?: FileLocation): AdapterConfig | undefined;
+/**
+ * Guess every format `@jbrowse/add-track-core`'s table describes — the same
+ * table `@jbrowse/cli`'s `add-track` reads, so a file resolves to the same
+ * adapter config in the app and on the command line.
+ *
+ * Whether a build can open a format is decided by `hasAdapterType`, not by the
+ * table: guessing `BamAdapter` in a build with no alignments plugin writes a
+ * track config that fails at render. A plugin therefore registers its adapters
+ * and nothing else — there is no format list to keep in step. ADR-077.
+ *
+ * `CorePlugin` installs this first, so any `addAdapterGuesser` a plugin
+ * registers is later in the chain and wins over the table. That is how a format
+ * the table cannot express is added, and how a third-party plugin claims one.
+ */
+export declare function installFormatGuessers(pluginManager: PluginManager): void;