@gmod/gbz-base 0.0.1

package/dist/gbwt/node.d.ts

@@ -0,0 +1,15 @@
+export declare const ENDMARKER = 0;
+export type Orientation = 'forward' | 'reverse';
+export declare function encodeNode(id: number, orientation: Orientation): number;
+export declare function nodeId(handle: number): number;
+export declare function nodeOrientation(handle: number): Orientation;
+export declare function isReverse(handle: number): boolean;
+export declare function flipNode(handle: number): number;
+export type NodeSide = 'left' | 'right';
+export declare function flipSide(side: NodeSide): NodeSide;
+export declare function entrySide(orientation: Orientation): NodeSide;
+export declare function exitSide(orientation: Orientation): NodeSide;
+export declare function entryOrientation(side: NodeSide): Orientation;
+export declare function exitOrientation(side: NodeSide): Orientation;
+export declare function edgeIsCanonical(from: number, to: number): boolean;
+export declare function pathIsCanonical(path: number[]): boolean;

package/dist/gbwt/node.js

@@ -0,0 +1,44 @@
+export const ENDMARKER = 0;
+export function encodeNode(id, orientation) {
+    return 2 * id + (orientation === 'reverse' ? 1 : 0);
+}
+export function nodeId(handle) {
+    return Math.floor(handle / 2);
+}
+export function nodeOrientation(handle) {
+    return handle % 2 === 0 ? 'forward' : 'reverse';
+}
+export function isReverse(handle) {
+    return handle % 2 === 1;
+}
+export function flipNode(handle) {
+    return handle % 2 === 0 ? handle + 1 : handle - 1;
+}
+export function flipSide(side) {
+    return side === 'left' ? 'right' : 'left';
+}
+export function entrySide(orientation) {
+    return orientation === 'forward' ? 'left' : 'right';
+}
+export function exitSide(orientation) {
+    return orientation === 'forward' ? 'right' : 'left';
+}
+export function entryOrientation(side) {
+    return side === 'left' ? 'forward' : 'reverse';
+}
+export function exitOrientation(side) {
+    return side === 'right' ? 'forward' : 'reverse';
+}
+export function edgeIsCanonical(from, to) {
+    const fromId = nodeId(from);
+    const toId = nodeId(to);
+    return isReverse(from) ? toId > fromId || (toId === fromId && !isReverse(to)) : toId >= fromId;
+}
+export function pathIsCanonical(path) {
+    const first = path[0];
+    const last = path[path.length - 1];
+    if (first === undefined || last === undefined) {
+        return true;
+    }
+    return isReverse(first) === isReverse(last) ? !isReverse(first) : edgeIsCanonical(first, last);
+}

package/dist/gbwt/record.d.ts

@@ -0,0 +1,18 @@
+import { RunReader } from './bytecode.ts';
+export interface Pos {
+    node: number;
+    offset: number;
+}
+export declare function decompressEdges(bytes: Uint8Array): Pos[];
+export declare class GbwtRecord {
+    readonly edges: Pos[];
+    readonly bwt: Uint8Array;
+    constructor(edges: Pos[], bwt: Uint8Array);
+    runs(): RunReader;
+    private edge;
+    lf(i: number): Pos | undefined;
+    private edgeTo;
+    offsetTo(pos: Pos): number | undefined;
+    predecessorAt(i: number): number | undefined;
+    decompress(): Pos[];
+}

package/dist/gbwt/record.js

@@ -0,0 +1,133 @@
+import { ByteCodeReader, RunReader } from "./bytecode.js";
+import { ENDMARKER, flipNode, nodeId } from "./node.js";
+export function decompressEdges(bytes) {
+    const reader = new ByteCodeReader(bytes);
+    const sigma = reader.int();
+    if (sigma === undefined || sigma === 0) {
+        return [];
+    }
+    const edges = [];
+    let prev = 0;
+    for (let i = 0; i < sigma; i++) {
+        const delta = reader.int();
+        const offset = reader.int();
+        if (delta === undefined || offset === undefined) {
+            throw new Error('GBWT edge list ends early');
+        }
+        prev += delta;
+        edges.push({ node: prev, offset });
+    }
+    return edges;
+}
+export class GbwtRecord {
+    edges;
+    bwt;
+    constructor(edges, bwt) {
+        this.edges = edges;
+        this.bwt = bwt;
+    }
+    runs() {
+        return new RunReader(this.bwt, this.edges.length);
+    }
+    edge(rank) {
+        const edge = this.edges[rank];
+        if (edge === undefined) {
+            throw new Error(`GBWT run refers to edge rank ${rank} of ${this.edges.length}`);
+        }
+        return edge;
+    }
+    lf(i) {
+        const offsets = this.edges.map(e => e.offset);
+        let offset = 0;
+        for (const run of this.runs()) {
+            const edge = this.edge(run.value);
+            const soFar = offsets[run.value];
+            if (offset + run.len > i) {
+                return edge.node === ENDMARKER ? undefined : { node: edge.node, offset: soFar + (i - offset) };
+            }
+            offsets[run.value] = soFar + run.len;
+            offset += run.len;
+        }
+        return undefined;
+    }
+    edgeTo(node) {
+        let low = 0;
+        let high = this.edges.length;
+        while (low < high) {
+            const mid = (low + high) >> 1;
+            const edge = this.edges[mid];
+            if (edge.node === node) {
+                return mid;
+            }
+            if (edge.node < node) {
+                low = mid + 1;
+            }
+            else {
+                high = mid;
+            }
+        }
+        return undefined;
+    }
+    offsetTo(pos) {
+        if (pos.node === ENDMARKER) {
+            return undefined;
+        }
+        const rank = this.edgeTo(pos.node);
+        if (rank === undefined) {
+            return undefined;
+        }
+        let succRank = this.edges[rank].offset;
+        if (succRank > pos.offset) {
+            return undefined;
+        }
+        let offset = 0;
+        for (const run of this.runs()) {
+            offset += run.len;
+            if (run.value !== rank) {
+                continue;
+            }
+            succRank += run.len;
+            if (succRank > pos.offset) {
+                return offset - (succRank - pos.offset);
+            }
+        }
+        return undefined;
+    }
+    predecessorAt(i) {
+        const counts = this.edges.map(e => ({ node: e.node === ENDMARKER ? ENDMARKER : flipNode(e.node), count: 0 }));
+        for (const run of this.runs()) {
+            const entry = counts[run.value];
+            if (entry) {
+                entry.count += run.len;
+            }
+        }
+        for (let rank = 1; rank < counts.length; rank++) {
+            const prev = counts[rank - 1];
+            const curr = counts[rank];
+            if (nodeId(prev.node) === nodeId(curr.node)) {
+                counts[rank - 1] = curr;
+                counts[rank] = prev;
+            }
+        }
+        let offset = 0;
+        for (const entry of counts) {
+            offset += entry.count;
+            if (offset > i) {
+                return entry.node === ENDMARKER ? undefined : entry.node;
+            }
+        }
+        return undefined;
+    }
+    decompress() {
+        const offsets = this.edges.map(e => e.offset);
+        const result = [];
+        for (const run of this.runs()) {
+            const edge = this.edge(run.value);
+            for (let k = 0; k < run.len; k++) {
+                result.push({ node: edge.node, offset: offsets[run.value] });
+                offsets[run.value] = offsets[run.value] + 1;
+            }
+        }
+        return result;
+    }
+}

package/dist/gbwt/sequence.d.ts

@@ -0,0 +1,3 @@
+export declare function encodedSequenceLength(encoded: Uint8Array): number;
+export declare function decodeSequence(encoded: Uint8Array): string;
+export declare function reverseComplement(sequence: string): string;

package/dist/gbwt/sequence.js

@@ -0,0 +1,40 @@
+const DECODE = ['', 'A', 'C', 'G', 'T', 'N'];
+export function encodedSequenceLength(encoded) {
+    const last = encoded[encoded.length - 1];
+    if (last === undefined) {
+        return 0;
+    }
+    let value = last;
+    let inLast = 0;
+    for (let i = 0; i < 3; i++) {
+        if (value % 6 === 0) {
+            break;
+        }
+        value = Math.floor(value / 6);
+        inLast += 1;
+    }
+    return 3 * (encoded.length - 1) + inLast;
+}
+export function decodeSequence(encoded) {
+    let result = '';
+    for (const byte of encoded) {
+        let value = byte;
+        for (let i = 0; i < 3; i++) {
+            const base = DECODE[value % 6];
+            if (base === '') {
+                return result;
+            }
+            value = Math.floor(value / 6);
+            result += base;
+        }
+    }
+    return result;
+}
+const COMPLEMENT = { A: 'T', C: 'G', G: 'C', T: 'A', N: 'N' };
+export function reverseComplement(sequence) {
+    let result = '';
+    for (let i = sequence.length - 1; i >= 0; i--) {
+        result += COMPLEMENT[sequence[i]] ?? 'N';
+    }
+    return result;
+}

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+export { GBZBase, GbzRecord, SchemaVersionError, formatPathName, GENERIC_SAMPLE, SCHEMA_VERSION } from './db.ts';
+export type { GbzPath, HaplotypeSample, PathName } from './db.ts';
+export type { ByteSource } from './filehandle.ts';
+export type { Pos } from './gbwt/record.ts';
+export { Subgraph } from './subgraph.ts';
+export type { HaplotypeAlignment, HaplotypeOutput, PathIdentity, PathPosition, ReferencePath, SubgraphJson, SubgraphPath, ToJsonOptions, } from './subgraph.ts';
+export { subgraphAtOffset, subgraphInInterval, subgraphAroundNodes } from './query.ts';
+export type { PathQuery, QueryOptions } from './query.ts';
+export { SqliteDatabase } from './sqlite/database.ts';
+export { weightedLcs } from './lcs.ts';
+export * as nodes from './gbwt/node.ts';

package/dist/index.js

@@ -0,0 +1,6 @@
+export { GBZBase, GbzRecord, SchemaVersionError, formatPathName, GENERIC_SAMPLE, SCHEMA_VERSION } from "./db.js";
+export { Subgraph } from "./subgraph.js";
+export { subgraphAtOffset, subgraphInInterval, subgraphAroundNodes } from "./query.js";
+export { SqliteDatabase } from "./sqlite/database.js";
+export { weightedLcs } from "./lcs.js";
+export * as nodes from "./gbwt/node.js";

package/dist/lcs.d.ts

@@ -0,0 +1 @@
+export declare function weightedLcs(a: number[], b: number[], weight: (x: number) => number): [pairs: [number, number][], weight: number];

package/dist/lcs.js

@@ -0,0 +1,214 @@
+function prefixSums(sequence, weight) {
+    const sums = [0];
+    for (let i = 0; i < sequence.length; i++) {
+        sums.push(sums[i] + weight(sequence[i]));
+    }
+    return sums;
+}
+class MinHeap {
+    items = [];
+    push(value) {
+        const items = this.items;
+        items.push(value);
+        let i = items.length - 1;
+        while (i > 0) {
+            const parent = (i - 1) >> 1;
+            if (items[parent] <= value) {
+                break;
+            }
+            items[i] = items[parent];
+            i = parent;
+        }
+        items[i] = value;
+    }
+    peek() {
+        return this.items[0];
+    }
+    pop() {
+        const items = this.items;
+        const top = items[0];
+        const last = items.pop();
+        if (items.length > 0 && last !== undefined) {
+            let i = 0;
+            for (;;) {
+                const left = 2 * i + 1;
+                const right = left + 1;
+                let smallest = i;
+                let value = last;
+                if (left < items.length && items[left] < value) {
+                    smallest = left;
+                    value = items[left];
+                }
+                if (right < items.length && items[right] < value) {
+                    smallest = right;
+                }
+                if (smallest === i) {
+                    break;
+                }
+                items[i] = items[smallest];
+                i = smallest;
+            }
+            items[i] = last;
+        }
+        return top;
+    }
+}
+class Matrix {
+    a;
+    b;
+    aSums;
+    bSums;
+    points = new Map();
+    pendingEdits = new MinHeap();
+    constructor(a, b, weight) {
+        this.a = a;
+        this.b = b;
+        this.aSums = prefixSums(a, weight);
+        this.bSums = prefixSums(b, weight);
+        this.set(0, 0, { weight: 0, a: 0, b: 0, matches: 0 });
+    }
+    set(edits, diagonal, point) {
+        let row = this.points.get(edits);
+        if (!row) {
+            row = new Map();
+            this.points.set(edits, row);
+            this.pendingEdits.push(edits);
+        }
+        row.set(diagonal, point);
+    }
+    get(edits, diagonal) {
+        return this.points.get(edits)?.get(diagonal);
+    }
+    tryInsert(edits, diagonal, point) {
+        const existing = this.get(edits, diagonal);
+        if (!existing || point.weight > existing.weight) {
+            this.set(edits, diagonal, point);
+        }
+    }
+    aWeight(offset) {
+        return this.aSums[offset + 1] - this.aSums[offset];
+    }
+    bWeight(offset) {
+        return this.bSums[offset + 1] - this.bSums[offset];
+    }
+    extend(edits) {
+        const row = this.points.get(edits);
+        if (!row) {
+            return undefined;
+        }
+        const diagonals = [...row.keys()].sort((x, y) => x - y);
+        for (const diagonal of diagonals) {
+            const found = row.get(diagonal);
+            if (!found) {
+                continue;
+            }
+            const point = { ...found };
+            while (point.a < this.a.length && point.b < this.b.length && this.a[point.a] === this.b[point.b]) {
+                point.weight += 2 * this.aWeight(point.a);
+                point.a += 1;
+                point.b += 1;
+                point.matches += 1;
+            }
+            if (point.matches > 0) {
+                row.set(diagonal, point);
+            }
+            if (point.a === this.a.length && point.b === this.b.length) {
+                return point;
+            }
+            if (point.a < this.a.length) {
+                const w = this.aWeight(point.a);
+                this.tryInsert(edits + w, diagonal + w, { weight: point.weight, a: point.a + 1, b: point.b, matches: 0 });
+            }
+            if (point.b < this.b.length) {
+                const w = this.bWeight(point.b);
+                this.tryInsert(edits + w, diagonal - w, { weight: point.weight, a: point.a, b: point.b + 1, matches: 0 });
+            }
+        }
+        return undefined;
+    }
+    nextEdits(edits) {
+        while (this.pendingEdits.peek() !== undefined && this.pendingEdits.peek() <= edits) {
+            this.pendingEdits.pop();
+        }
+        return this.pendingEdits.peek();
+    }
+    predecessor(a, b, edits) {
+        const diagonal = this.aSums[a] - this.bSums[b];
+        const prev = a > 0 && this.aWeight(a - 1) <= edits ? this.get(edits - this.aWeight(a - 1), diagonal - this.aWeight(a - 1)) : undefined;
+        const next = b > 0 && this.bWeight(b - 1) <= edits ? this.get(edits - this.bWeight(b - 1), diagonal + this.bWeight(b - 1)) : undefined;
+        if (prev && next) {
+            return prev.weight > next.weight ? [prev, edits - this.aWeight(a - 1)] : [next, edits - this.bWeight(b - 1)];
+        }
+        if (prev) {
+            return [prev, edits - this.aWeight(a - 1)];
+        }
+        if (next) {
+            return [next, edits - this.bWeight(b - 1)];
+        }
+        return undefined;
+    }
+}
+export function weightedLcs(a, b, weight) {
+    let prefix = 0;
+    while (prefix < a.length && prefix < b.length && a[prefix] === b[prefix]) {
+        prefix += 1;
+    }
+    let suffix = 0;
+    while (suffix < a.length - prefix && suffix < b.length - prefix && a[a.length - 1 - suffix] === b[b.length - 1 - suffix]) {
+        suffix += 1;
+    }
+    const pairs = [];
+    let total = 0;
+    for (let i = 0; i < prefix; i++) {
+        pairs.push([i, i]);
+        total += weight(a[i]);
+    }
+    const [middle, middleWeight] = weightedLcsCore(a.slice(prefix, a.length - suffix), b.slice(prefix, b.length - suffix), weight);
+    for (const [i, j] of middle) {
+        pairs.push([i + prefix, j + prefix]);
+    }
+    total += middleWeight;
+    for (let i = suffix; i > 0; i--) {
+        pairs.push([a.length - i, b.length - i]);
+        total += weight(a[a.length - i]);
+    }
+    return [pairs, total];
+}
+function weightedLcsCore(a, b, weight) {
+    if (a.length === 0 || b.length === 0) {
+        return [[], 0];
+    }
+    const matrix = new Matrix(a, b, weight);
+    let edits = 0;
+    let point = { weight: 0, a: 0, b: 0, matches: 0 };
+    for (;;) {
+        const end = matrix.extend(edits);
+        if (end) {
+            point = end;
+            break;
+        }
+        const next = matrix.nextEdits(edits);
+        if (next === undefined) {
+            break;
+        }
+        edits = next;
+    }
+    const result = [];
+    const finalWeight = point.weight / 2;
+    point = { ...point };
+    for (;;) {
+        for (let i = 0; i < point.matches; i++) {
+            point.a -= 1;
+            point.b -= 1;
+            result.push([point.a, point.b]);
+        }
+        const pred = matrix.predecessor(point.a, point.b, edits);
+        if (!pred) {
+            break;
+        }
+        point = { ...pred[0] };
+        edits = pred[1];
+    }
+    result.reverse();
+    return [result, finalWeight];
+}

package/dist/query.d.ts

@@ -0,0 +1,16 @@
+import type { GBZBase } from './db.ts';
+import { Subgraph } from './subgraph.ts';
+import type { HaplotypeOutput } from './subgraph.ts';
+export interface QueryOptions {
+    context?: number;
+    haplotypes?: HaplotypeOutput;
+    limit?: number;
+}
+export interface PathQuery {
+    sample?: string;
+    contig: string;
+    haplotype?: number;
+}
+export declare function subgraphAtOffset(db: GBZBase, query: PathQuery, offset: number, opts?: QueryOptions): Promise<Subgraph>;
+export declare function subgraphInInterval(db: GBZBase, query: PathQuery, start: number, end: number, opts?: QueryOptions): Promise<Subgraph>;
+export declare function subgraphAroundNodes(db: GBZBase, nodes: number[], opts?: QueryOptions): Promise<Subgraph>;

package/dist/query.js

@@ -0,0 +1,37 @@
+import { GENERIC_SAMPLE } from "./db.js";
+import { Subgraph } from "./subgraph.js";
+function pathName(query, fragment) {
+    return {
+        sample: query.sample ?? GENERIC_SAMPLE,
+        contig: query.contig,
+        haplotype: query.haplotype ?? 0,
+        fragment,
+    };
+}
+export async function subgraphAtOffset(db, query, offset, opts = {}) {
+    const subgraph = new Subgraph(db);
+    subgraph.limit = opts.limit;
+    const reference = await subgraph.pathPosition(pathName(query, offset));
+    await subgraph.aroundPosition(reference.position.handle, reference.position.nodeOffset, opts.context ?? 100);
+    subgraph.extractPaths(reference, opts.haplotypes ?? 'all');
+    return subgraph;
+}
+export async function subgraphInInterval(db, query, start, end, opts = {}) {
+    const subgraph = new Subgraph(db);
+    subgraph.limit = opts.limit;
+    const reference = await subgraph.pathPosition(pathName(query, start));
+    await subgraph.aroundInterval(reference.position, end - start, opts.context ?? 100);
+    subgraph.extractPaths(reference, opts.haplotypes ?? 'all');
+    return subgraph;
+}
+export async function subgraphAroundNodes(db, nodes, opts = {}) {
+    const haplotypes = opts.haplotypes ?? 'all';
+    if (haplotypes === 'reference-only') {
+        throw new Error('Cannot output a reference path in a node-based query');
+    }
+    const subgraph = new Subgraph(db);
+    subgraph.limit = opts.limit;
+    await subgraph.aroundNodes(nodes, opts.context ?? 100);
+    subgraph.extractPaths(undefined, haplotypes);
+    return subgraph;
+}

package/dist/sqlite/btree.d.ts

@@ -0,0 +1,18 @@
+import type { Pager } from './pager.ts';
+import type { SqlValue } from './record.ts';
+export declare class BTree {
+    private pager;
+    private readonly usable;
+    constructor(pager: Pager, reservedBytes: number);
+    private localPayloadSize;
+    private payload;
+    private pageAt;
+    tableRowid(root: number, rowid: number): Promise<SqlValue[] | undefined>;
+    tableScan(root: number): AsyncGenerator<{
+        rowid: number;
+        values: SqlValue[];
+    }>;
+    private indexCell;
+    indexScanFrom(root: number, low: number[]): AsyncGenerator<SqlValue[]>;
+    indexSeekLE(root: number, key: number[]): Promise<SqlValue[] | undefined>;
+}