@jbrowse/core 3.7.0 → 4.0.0

package/util/flatbush/index.js

@@ -1,362 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const flatqueue_1 = __importDefault(require("../flatqueue"));
-const ARRAY_TYPES = [
-    Int8Array,
-    Uint8Array,
-    Uint8ClampedArray,
-    Int16Array,
-    Uint16Array,
-    Int32Array,
-    Uint32Array,
-    Float32Array,
-    Float64Array,
-];
-const VERSION = 3;
-class Flatbush {
-    static from(data, byteOffset = 0) {
-        if (byteOffset % 8 !== 0) {
-            throw new Error('byteOffset must be 8-byte aligned.');
-        }
-        if ((data === null || data === void 0 ? void 0 : data.byteLength) === undefined || data.buffer) {
-            throw new Error('Data must be an instance of ArrayBuffer or SharedArrayBuffer.');
-        }
-        const [magic, versionAndType] = new Uint8Array(data, byteOffset + 0, 2);
-        if (magic !== 0xfb) {
-            throw new Error('Data does not appear to be in a Flatbush format.');
-        }
-        const version = versionAndType >> 4;
-        if (version !== VERSION) {
-            throw new Error(`Got v${version} data when expected v${VERSION}.`);
-        }
-        const ArrayType = ARRAY_TYPES[versionAndType & 0x0f];
-        if (!ArrayType) {
-            throw new Error('Unrecognized array type.');
-        }
-        const [nodeSize] = new Uint16Array(data, byteOffset + 2, 1);
-        const [numItems] = new Uint32Array(data, byteOffset + 4, 1);
-        return new Flatbush(numItems, nodeSize, ArrayType, undefined, data, byteOffset);
-    }
-    constructor(numItems, nodeSize = 16, ArrayType = Float64Array, ArrayBufferType = ArrayBuffer, data, byteOffset = 0) {
-        if (numItems === undefined) {
-            throw new Error('Missing required argument: numItems.');
-        }
-        if (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;
-        let n = numItems;
-        let numNodes = n;
-        this._levelBounds = [n * 4];
-        do {
-            n = Math.ceil(n / this.nodeSize);
-            numNodes += n;
-            this._levelBounds.push(numNodes * 4);
-        } while (n !== 1);
-        this.ArrayType = ArrayType;
-        this.IndexArrayType = numNodes < 16384 ? Uint16Array : Uint32Array;
-        const arrayTypeIndex = ARRAY_TYPES.indexOf(ArrayType);
-        const nodesByteSize = numNodes * 4 * ArrayType.BYTES_PER_ELEMENT;
-        if (arrayTypeIndex === -1) {
-            throw new Error(`Unexpected typed array class: ${ArrayType}.`);
-        }
-        if (data) {
-            this.data = data;
-            this._boxes = new ArrayType(data, byteOffset + 8, numNodes * 4);
-            this._indices = new this.IndexArrayType(data, byteOffset + 8 + nodesByteSize, numNodes);
-            this._pos = numNodes * 4;
-            this.minX = this._boxes[this._pos - 4];
-            this.minY = this._boxes[this._pos - 3];
-            this.maxX = this._boxes[this._pos - 2];
-            this.maxY = this._boxes[this._pos - 1];
-        }
-        else {
-            const data = (this.data = new ArrayBufferType(8 + nodesByteSize + numNodes * this.IndexArrayType.BYTES_PER_ELEMENT));
-            this._boxes = new ArrayType(data, 8, numNodes * 4);
-            this._indices = new this.IndexArrayType(data, 8 + nodesByteSize, numNodes);
-            this._pos = 0;
-            this.minX = Infinity;
-            this.minY = Infinity;
-            this.maxX = -Infinity;
-            this.maxY = -Infinity;
-            new Uint8Array(data, 0, 2).set([0xfb, (VERSION << 4) + arrayTypeIndex]);
-            new Uint16Array(data, 2, 1)[0] = nodeSize;
-            new Uint32Array(data, 4, 1)[0] = numItems;
-        }
-        this._queue = new flatqueue_1.default();
-    }
-    add(minX, minY, maxX = minX, maxY = minY) {
-        const index = this._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;
-        if (minX < this.minX) {
-            this.minX = minX;
-        }
-        if (minY < this.minY) {
-            this.minY = minY;
-        }
-        if (maxX > this.maxX) {
-            this.maxX = maxX;
-        }
-        if (maxY > this.maxY) {
-            this.maxY = maxY;
-        }
-        return index;
-    }
-    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) {
-            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 hilbertMax = (1 << 16) - 1;
-        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((hilbertMax * ((minX + maxX) / 2 - this.minX)) / width);
-            const y = Math.floor((hilbertMax * ((minY + maxY) / 2 - this.minY)) / height);
-            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++) {
-                    nodeMinX = Math.min(nodeMinX, boxes[pos++]);
-                    nodeMinY = Math.min(nodeMinY, boxes[pos++]);
-                    nodeMaxX = Math.max(nodeMaxX, boxes[pos++]);
-                    nodeMaxY = Math.max(nodeMaxY, boxes[pos++]);
-                }
-                this._indices[this._pos >> 2] = nodeIndex;
-                boxes[this._pos++] = nodeMinX;
-                boxes[this._pos++] = nodeMinY;
-                boxes[this._pos++] = nodeMaxX;
-                boxes[this._pos++] = nodeMaxY;
-            }
-        }
-    }
-    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 results = [];
-        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);
-                }
-            }
-            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);
-                }
-            }
-            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;
-                }
-            }
-            nodeIndex = q.length ? q.pop() >> 1 : undefined;
-        }
-        q.clear();
-        return results;
-    }
-}
-exports.default = Flatbush;
-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;
-        }
-        else {
-            i = m + 1;
-        }
-    }
-    return arr[i];
-}
-function sort(values, boxes, indices, left, right, nodeSize) {
-    if (Math.floor(left / nodeSize) >= Math.floor(right / nodeSize)) {
-        return;
-    }
-    const start = values[left];
-    const mid = values[(left + right) >> 1];
-    const end = values[right];
-    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);
-    }
-    let i = left - 1;
-    let j = right + 1;
-    while (true) {
-        do {
-            i++;
-        } while (values[i] < pivot);
-        do {
-            j--;
-        } while (values[j] > pivot);
-        if (i >= j) {
-            break;
-        }
-        swap(values, boxes, indices, i, j);
-    }
-    sort(values, boxes, indices, left, j, nodeSize);
-    sort(values, boxes, indices, j + 1, right, nodeSize);
-}
-function swap(values, boxes, indices, i, j) {
-    const temp = values[i];
-    values[i] = values[j];
-    values[j] = temp;
-    const k = 4 * i;
-    const m = 4 * j;
-    const a = boxes[k];
-    const b = boxes[k + 1];
-    const c = boxes[k + 2];
-    const d = boxes[k + 3];
-    boxes[k] = boxes[m];
-    boxes[k + 1] = boxes[m + 1];
-    boxes[k + 2] = boxes[m + 2];
-    boxes[k + 3] = boxes[m + 3];
-    boxes[m] = a;
-    boxes[m + 1] = b;
-    boxes[m + 2] = c;
-    boxes[m + 3] = d;
-    const e = indices[i];
-    indices[i] = indices[j];
-    indices[j] = e;
-}
-function hilbert(x, y) {
-    let a = x ^ y;
-    let b = 0xffff ^ a;
-    let c = 0xffff ^ (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;
-    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;
-}

package/util/flatqueue/index.js

@@ -1,66 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-class FlatQueue {
-    constructor() {
-        this.ids = [];
-        this.values = [];
-        this.length = 0;
-    }
-    clear() {
-        this.length = 0;
-    }
-    push(item, priority) {
-        let pos = this.length++;
-        while (pos > 0) {
-            const parent = (pos - 1) >> 1;
-            const parentValue = this.values[parent];
-            if (priority >= parentValue) {
-                break;
-            }
-            this.ids[pos] = this.ids[parent];
-            this.values[pos] = parentValue;
-            pos = parent;
-        }
-        this.ids[pos] = item;
-        this.values[pos] = priority;
-    }
-    pop() {
-        if (this.length === 0) {
-            return undefined;
-        }
-        const ids = this.ids;
-        const values = this.values;
-        const top = ids[0];
-        const last = --this.length;
-        if (last > 0) {
-            const id = ids[last];
-            const value = values[last];
-            let pos = 0;
-            const halfLen = last >> 1;
-            while (pos < halfLen) {
-                const left = (pos << 1) + 1;
-                const right = left + 1;
-                const child = left + (+(right < last) & +(values[right] < values[left]));
-                if (values[child] >= value) {
-                    break;
-                }
-                ids[pos] = ids[child];
-                values[pos] = values[child];
-                pos = child;
-            }
-            ids[pos] = id;
-            values[pos] = value;
-        }
-        return top;
-    }
-    peek() {
-        return this.length > 0 ? this.ids[0] : undefined;
-    }
-    peekValue() {
-        return this.length > 0 ? this.values[0] : undefined;
-    }
-    shrink() {
-        this.ids.length = this.values.length = this.length;
-    }
-}
-exports.default = FlatQueue;

package/util/formatFastaStrings.js

@@ -1,12 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.formatFastaLines = formatFastaLines;
-exports.formatSeqFasta = formatSeqFasta;
-function formatFastaLines(seqString) {
-    return seqString.replaceAll(/(.{1,80})/g, '$1\n').trimEnd();
-}
-function formatSeqFasta(chunks) {
-    return chunks
-        .map(chunk => `>${chunk.header}\n${formatFastaLines(chunk.seq)}`)
-        .join('\n');
-}

package/util/idMaker.js

@@ -1,24 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = idMaker;
-const _1 = require("./");
-function idMaker(args, id = '', len = 5000) {
-    const stack = [args];
-    while (stack.length) {
-        const obj = stack.pop();
-        for (const [key, val] of Object.entries(obj)) {
-            if (id.length > len) {
-                return (0, _1.hashCode)(id);
-            }
-            else {
-                if (typeof val === 'object' && val !== null) {
-                    stack.push(val);
-                }
-                else {
-                    id += `${key}-${val}`;
-                }
-            }
-        }
-    }
-    return `adp-${(0, _1.hashCode)(id)}`;
-}