@gmod/gbz-base 0.0.1 → 1.1.0

package/dist/subgraph.js

@@ -1,32 +1,64 @@
 import { formatPathName } from "./db.js";
-import { ENDMARKER, edgeIsCanonical, encodeNode, entryOrientation, entrySide, exitOrientation, exitSide, flipSide, isReverse, nodeId, nodeOrientation, pathIsCanonical, } from "./gbwt/node.js";
+import { ENDMARKER, edgeIsCanonical, encodeNode, entryOrientation, entrySide, exitOrientation, exitSide, flipNode, flipSide, isReverse, nodeId, nodeOrientation, pathIsCanonical, } from "./gbwt/node.js";
+import { gfaHeaderLines, sha256Hex, subgraphName } from "./graphName.js";
 import { weightedLcs } from "./lcs.js";
+function sideBefore(a, b) {
+    return (a[0] < b[0] ||
+        (a[0] === b[0] && (a[1] < b[1] || (a[1] === b[1] && a[2] < b[2]))));
+}
 class SideQueue {
-    items = [];
+    heap = [];
     push(distance, node, side) {
-        this.items.push([distance, node, side]);
+        const heap = this.heap;
+        heap.push([distance, node, side]);
+        let i = heap.length - 1;
+        while (i > 0) {
+            const parent = (i - 1) >> 1;
+            if (sideBefore(heap[i], heap[parent])) {
+                ;
+                [heap[i], heap[parent]] = [heap[parent], heap[i]];
+                i = parent;
+            }
+            else {
+                break;
+            }
+        }
     }
     pop() {
-        let best = 0;
-        for (let i = 1; i < this.items.length; i++) {
-            const a = this.items[i];
-            const b = this.items[best];
-            if (a[0] < b[0] || (a[0] === b[0] && (a[1] < b[1] || (a[1] === b[1] && a[2] < b[2])))) {
-                best = i;
+        const heap = this.heap;
+        const top = heap[0];
+        const last = heap.pop();
+        if (heap.length > 0 && last !== undefined) {
+            heap[0] = last;
+            let i = 0;
+            for (;;) {
+                const left = 2 * i + 1;
+                const right = left + 1;
+                let smallest = i;
+                if (left < heap.length && sideBefore(heap[left], heap[smallest])) {
+                    smallest = left;
+                }
+                if (right < heap.length && sideBefore(heap[right], heap[smallest])) {
+                    smallest = right;
+                }
+                if (smallest === i) {
+                    break;
+                }
+                ;
+                [heap[i], heap[smallest]] = [heap[smallest], heap[i]];
+                i = smallest;
             }
         }
-        const [item] = this.items.splice(best, 1);
-        return item;
+        return top;
     }
     get size() {
-        return this.items.length;
+        return this.heap.length;
     }
 }
 function posKey(pos) {
     return `${pos.node}:${pos.offset}`;
 }
 export class Subgraph {
-    db;
     records = new Map();
     paths = [];
     refId;
@@ -36,7 +68,13 @@ export class Subgraph {
     refIndexCache;
     refPrefixCache;
     limit;
-    stats = { orderedAlignments: 0, lcsAlignments: 0, identificationSteps: 0, identificationFetches: 0 };
+    stats = {
+        orderedAlignments: 0,
+        lcsAlignments: 0,
+        identificationSteps: 0,
+        identificationFetches: 0,
+    };
+    db;
     constructor(db) {
         this.db = db;
     }
@@ -48,7 +86,11 @@ export class Subgraph {
     }
     get referenceInterval() {
         return this.refInterval && this.refPath
-            ? { name: this.refPath, start: this.refPath.fragment + this.refInterval[0], end: this.refPath.fragment + this.refInterval[1] }
+            ? {
+                name: this.refPath,
+                start: this.refPath.fragment + this.refInterval[0],
+                end: this.refPath.fragment + this.refInterval[1],
+            }
             : undefined;
     }
     hasNode(id) {
@@ -116,7 +158,12 @@ export class Subgraph {
             const record = this.record(pos.node);
             if (pathOffset + record.sequenceLen > queryOffset) {
                 return {
-                    position: { seqOffset: queryOffset, handle: pos.node, nodeOffset: queryOffset - pathOffset, gbwtOffset: pos.offset },
+                    position: {
+                        seqOffset: queryOffset,
+                        handle: pos.node,
+                        nodeOffset: queryOffset - pathOffset,
+                        gbwtOffset: pos.offset,
+                    },
                     name: path.name,
                     handle: path.handle,
                 };
@@ -227,6 +274,139 @@ export class Subgraph {
         }
         return { inserted, removed: toRemove.size };
     }
+    async betweenNodes(start, end) {
+        this.clearPaths();
+        const active = [start, flipNode(end)];
+        const visited = new Set([nodeId(start), nodeId(end)]);
+        let inserted = 0;
+        while (active.length > 0) {
+            const curr = active.pop();
+            const id = nodeId(curr);
+            if (!this.hasNode(id)) {
+                await this.addNode(id);
+                inserted += 1;
+            }
+            for (const successor of this.record(curr).successors()) {
+                const successorId = nodeId(successor);
+                if (!visited.has(successorId)) {
+                    active.push(successor, flipNode(successor));
+                    visited.add(successorId);
+                }
+            }
+        }
+        return inserted;
+    }
+    async extractSnarls(snarls) {
+        let inserted = 0;
+        for (const [start, end] of await this.overlappingSnarls(snarls)) {
+            inserted += await this.betweenNodes(start, end);
+        }
+        return inserted;
+    }
+    async overlappingSnarls(snarls) {
+        const result = [];
+        if (snarls !== 'none') {
+            let foundLink = false;
+            for (const handle of this.sortedHandles()) {
+                const record = this.record(handle);
+                const next = record.next;
+                if (next !== undefined) {
+                    foundLink = true;
+                    if (this.hasHandle(next)) {
+                        if (edgeIsCanonical(handle, next)) {
+                            result.push([handle, next]);
+                        }
+                    }
+                    else if (snarls === 'overlapping' &&
+                        this.isSnarlEntryInSubgraph(record)) {
+                        result.push([handle, next]);
+                    }
+                }
+            }
+            if (!foundLink &&
+                snarls === 'overlapping' &&
+                (await this.db.hasChainLinks())) {
+                const covering = await this.findCoveringSnarl();
+                if (covering) {
+                    result.push(covering);
+                }
+            }
+        }
+        return result;
+    }
+    isSnarlEntryInSubgraph(record) {
+        const successors = record.successors();
+        const first = successors.find(handle => this.hasHandle(handle));
+        return first === undefined
+            ? false
+            : successors.length > 1 ||
+                this.record(flipNode(first)).successors().length > 1;
+    }
+    recordReader(onFetch) {
+        const outside = new Map();
+        return async (handle) => {
+            const inside = this.records.get(handle);
+            if (inside) {
+                return inside;
+            }
+            let record = outside.get(handle);
+            if (!record) {
+                record = await this.db.getRecord(handle);
+                onFetch?.();
+                if (!record) {
+                    throw new Error(`Node record ${handle} is missing from the database`);
+                }
+                outside.set(handle, record);
+            }
+            return record;
+        };
+    }
+    async findCoveringSnarl() {
+        const read = this.recordReader();
+        const isSnarlEntry = async (record) => {
+            const successors = record.successors();
+            const first = successors[0];
+            return first === undefined
+                ? false
+                : successors.length > 1 ||
+                    (await read(flipNode(first))).successors().length > 1;
+        };
+        const classify = async (handle) => {
+            const reverse = await read(flipNode(handle));
+            return reverse.next !== undefined
+                ? (await isSnarlEntry(reverse))
+                    ? { kind: 'snarl-exit', snarl: [flipNode(handle), reverse.next] }
+                    : { kind: 'chain' }
+                : (await read(handle)).next !== undefined
+                    ? { kind: 'chain' }
+                    : { kind: 'regular' };
+        };
+        const visited = new Set();
+        const queue = this.sortedHandles().flatMap(handle => this.record(handle).successors());
+        let result;
+        let done = false;
+        while (!done && queue.length > 0) {
+            const handle = queue.shift();
+            const id = nodeId(handle);
+            if (!this.hasHandle(handle) && !visited.has(id)) {
+                visited.add(id);
+                const type = await classify(handle);
+                if (type.kind === 'snarl-exit') {
+                    result = type.snarl;
+                    done = true;
+                }
+                else if (type.kind === 'chain') {
+                    done = true;
+                }
+                else {
+                    for (const orientation of ['forward', 'reverse']) {
+                        queue.push(...(await read(encodeNode(id, orientation))).successors());
+                    }
+                }
+            }
+        }
+        return result;
+    }
     extractPaths(reference, output) {
         this.clearPaths();
         if (output === 'none') {
@@ -238,47 +418,65 @@ export class Subgraph {
         const handles = this.sortedHandles();
         const successors = new Map();
         for (const handle of handles) {
-            successors.set(handle, this.record(handle)
-                .gbwt()
-                .decompress()
-                .map(next => ({ next, hasPredecessor: false })));
+            const { nodes, offsets } = this.record(handle).gbwt().decompressArrays();
+            successors.set(handle, {
+                nodes,
+                offsets,
+                hasPredecessor: new Uint8Array(nodes.length),
+            });
         }
         for (const handle of handles) {
-            for (const { next } of successors.get(handle)) {
-                const entry = successors.get(next.node)?.[next.offset];
+            const { nodes, offsets } = successors.get(handle);
+            for (let i = 0; i < nodes.length; i++) {
+                const entry = successors.get(nodes[i]);
                 if (entry) {
-                    entry.hasPredecessor = true;
+                    entry.hasPredecessor[offsets[i]] = 1;
                 }
             }
         }
         let refOffset;
         for (const handle of handles) {
             const entries = successors.get(handle);
-            entries.forEach((entry, offset) => {
-                if (entry.hasPredecessor) {
-                    return;
-                }
-                let curr = { node: handle, offset };
-                let isRef = false;
-                const path = [];
-                const positions = [];
-                let len = 0;
-                while (curr) {
-                    if (refPos && curr.node === refPos.handle && curr.offset === refPos.gbwtOffset) {
-                        this.refId = this.paths.length;
-                        refOffset = path.length;
-                        isRef = true;
+            for (let offset = 0; offset < entries.nodes.length; offset++) {
+                if (entries.hasPredecessor[offset] === 0) {
+                    let currNode = handle;
+                    let currOffset = offset;
+                    let isRef = false;
+                    const path = [];
+                    const positions = [];
+                    let len = 0;
+                    while (currNode !== undefined) {
+                        if (currNode === refPos?.handle &&
+                            currOffset === refPos.gbwtOffset) {
+                            this.refId = this.paths.length;
+                            refOffset = path.length;
+                            isRef = true;
+                        }
+                        path.push(currNode);
+                        positions.push({ node: currNode, offset: currOffset });
+                        len += this.record(currNode).sequenceLen;
+                        const step = successors.get(currNode);
+                        const nextNode = step.nodes[currOffset];
+                        const nextOffset = step.offsets[currOffset];
+                        if (nextNode !== ENDMARKER && successors.has(nextNode)) {
+                            currNode = nextNode;
+                            currOffset = nextOffset;
+                        }
+                        else {
+                            currNode = undefined;
+                        }
+                    }
+                    if (isRef || pathIsCanonical(path)) {
+                        this.paths.push({
+                            path,
+                            positions,
+                            len,
+                            weight: undefined,
+                            identity: undefined,
+                        });
                     }
-                    path.push(curr.node);
-                    positions.push(curr);
-                    len += this.record(curr.node).sequenceLen;
-                    const step = successors.get(curr.node)?.[curr.offset];
-                    curr = step && step.next.node !== ENDMARKER && successors.has(step.next.node) ? step.next : undefined;
-                }
-                if (isRef || pathIsCanonical(path)) {
-                    this.paths.push({ path, positions, len, weight: undefined, identity: undefined });
                 }
-            });
+            }
         }
         if (refPos) {
             if (refOffset === undefined || this.refId === undefined) {
@@ -292,9 +490,13 @@ export class Subgraph {
             }
             const start = refPos.seqOffset - before;
             this.refInterval = [start, start + info.len];
-            if (reference) {
-                info.identity = { pathHandle: reference.handle, name: reference.name, orientation: 'forward', hapStart: start, hapEnd: start + info.len };
-            }
+            info.identity = {
+                pathHandle: reference.handle,
+                name: reference.name,
+                orientation: 'forward',
+                hapStart: start,
+                hapEnd: start + info.len,
+            };
         }
         if (output === 'distinct') {
             this.distinctPaths();
@@ -349,23 +551,9 @@ export class Subgraph {
                 starts.set(posKey(first), index);
             }
         });
-        const outside = new Map();
-        const recordAt = async (handle) => {
-            const inside = this.records.get(handle);
-            if (inside) {
-                return inside;
-            }
-            let record = outside.get(handle);
-            if (!record) {
-                record = await this.db.getRecord(handle);
-                this.stats.identificationFetches += 1;
-                if (!record) {
-                    throw new Error(`Node record ${handle} is missing from the database`);
-                }
-                outside.set(handle, record);
-            }
-            return record;
-        };
+        const recordAt = this.recordReader(() => {
+            this.stats.identificationFetches += 1;
+        });
         const sampleAt = async (pos) => {
             if (pos.node >= minHandle && pos.node <= maxHandle) {
                 return samples.get(posKey(pos));
@@ -387,11 +575,27 @@ export class Subgraph {
             return name;
         };
         const anchorFromSample = (sample, counter, nodeLen) => sample.orientation === 'forward'
-            ? { pathHandle: sample.pathHandle, orientation: 'forward', base: sample.pathOffset - counter }
-            : { pathHandle: sample.pathHandle, orientation: 'reverse', base: sample.pathOffset + counter + nodeLen };
+            ? {
+                pathHandle: sample.pathHandle,
+                orientation: 'forward',
+                base: sample.pathOffset - counter,
+            }
+            : {
+                pathHandle: sample.pathHandle,
+                orientation: 'reverse',
+                base: sample.pathOffset + counter + nodeLen,
+            };
         const anchorFromIdentity = (identity, counter) => identity.orientation === 'forward'
-            ? { pathHandle: identity.pathHandle, orientation: 'forward', base: identity.hapStart - counter }
-            : { pathHandle: identity.pathHandle, orientation: 'reverse', base: identity.hapEnd + counter };
+            ? {
+                pathHandle: identity.pathHandle,
+                orientation: 'forward',
+                base: identity.hapStart - counter,
+            }
+            : {
+                pathHandle: identity.pathHandle,
+                orientation: 'reverse',
+                base: identity.hapEnd + counter,
+            };
         for (let start = 0; start < this.paths.length; start++) {
             const startInfo = this.paths[start];
             if (start === this.refId || startInfo.identity) {
@@ -449,7 +653,8 @@ export class Subgraph {
                     break;
                 }
                 this.stats.identificationSteps += 1;
-                if (counter - chain[chain.length - 1].startBp > 4 * interval + 4 * record.sequenceLen) {
+                if (counter - chain[chain.length - 1].startBp >
+                    4 * interval + 4 * record.sequenceLen) {
                     break;
                 }
                 counter += record.sequenceLen;
@@ -461,8 +666,20 @@ export class Subgraph {
                     const info = this.paths[index];
                     info.identity =
                         anchor.orientation === 'forward'
-                            ? { pathHandle: anchor.pathHandle, name, orientation: 'forward', hapStart: anchor.base + startBp, hapEnd: anchor.base + startBp + info.len }
-                            : { pathHandle: anchor.pathHandle, name, orientation: 'reverse', hapStart: anchor.base - startBp - info.len, hapEnd: anchor.base - startBp };
+                            ? {
+                                pathHandle: anchor.pathHandle,
+                                name,
+                                orientation: 'forward',
+                                hapStart: anchor.base + startBp,
+                                hapEnd: anchor.base + startBp + info.len,
+                            }
+                            : {
+                                pathHandle: anchor.pathHandle,
+                                name,
+                                orientation: 'reverse',
+                                hapStart: anchor.base - startBp - info.len,
+                                hapEnd: anchor.base - startBp,
+                            };
                 }
             }
         }
@@ -595,7 +812,9 @@ export class Subgraph {
         }
         else {
             const mismatch = Math.min(pathMiddle, refMiddle);
-            const mismatchIndel = 4 * mismatch + gapPenalty(pathMiddle - mismatch) + gapPenalty(refMiddle - mismatch);
+            const mismatchIndel = 4 * mismatch +
+                gapPenalty(pathMiddle - mismatch) +
+                gapPenalty(refMiddle - mismatch);
             const insertionDeletion = gapPenalty(pathMiddle) + gapPenalty(refMiddle);
             if (mismatchIndel <= insertionDeletion) {
                 appendEdit(edits, 'M', mismatch);
@@ -622,7 +841,8 @@ export class Subgraph {
         else {
             this.stats.lcsAlignments += 1;
         }
-        const lcs = ordered ?? weightedLcs(info.path, ref, handle => this.record(handle).sequenceLen)[0];
+        const lcs = ordered ??
+            weightedLcs(info.path, ref, handle => this.record(handle).sequenceLen)[0];
         const edits = [];
         let pathOffset = 0;
         let refOffset = 0;
@@ -636,7 +856,9 @@ export class Subgraph {
         return edits;
     }
     alignToRef(pathIndex) {
-        return this.edits(pathIndex)?.map(([op, len]) => `${len}${op}`).join('');
+        return this.edits(pathIndex)
+            ?.map(([op, len]) => `${len}${op}`)
+            .join('');
     }
     alignments() {
         const reference = this.referenceInterval;
@@ -664,12 +886,21 @@ export class Subgraph {
                 last -= 1;
             }
             const identity = info.identity;
-            const strand = info.path.some(handle => isReverse(handle)) && !info.path.some(handle => !isReverse(handle)) ? '-' : '+';
+            const strand = info.path.some(handle => isReverse(handle)) &&
+                !info.path.some(handle => !isReverse(handle))
+                ? '-'
+                : '+';
             result.push({
                 pathHandle: identity?.pathHandle,
                 name: identity?.name,
-                strand: identity ? (identity.orientation === 'forward' ? '+' : '-') : strand,
-                hapStart: identity ? identity.name.fragment + identity.hapStart : undefined,
+                strand: identity
+                    ? identity.orientation === 'forward'
+                        ? '+'
+                        : '-'
+                    : strand,
+                hapStart: identity
+                    ? identity.name.fragment + identity.hapStart
+                    : undefined,
                 hapEnd: identity ? identity.name.fragment + identity.hapEnd : undefined,
                 start: info.positions[0],
                 refStart: reference.start + leading,
@@ -684,11 +915,99 @@ export class Subgraph {
         });
         return result;
     }
+    canonicalEdges(id) {
+        const edges = [];
+        for (const orientation of ['forward', 'reverse']) {
+            const handle = encodeNode(id, orientation);
+            for (const successor of this.record(handle).successors()) {
+                if (this.hasHandle(successor) && edgeIsCanonical(handle, successor)) {
+                    edges.push([
+                        orientation === 'reverse' ? 1 : 0,
+                        nodeId(successor),
+                        isReverse(successor) ? 1 : 0,
+                    ]);
+                }
+            }
+        }
+        edges.sort((a, b) => a[0] - b[0] || a[1] - b[1] || a[2] - b[2]);
+        return edges.filter((edge, i) => i === 0 ||
+            edge[0] !== edges[i - 1][0] ||
+            edge[1] !== edges[i - 1][1] ||
+            edge[2] !== edges[i - 1][2]);
+    }
+    async stableName() {
+        const encoder = new TextEncoder();
+        const chunks = [];
+        for (const handle of this.sortedHandles()) {
+            if (!isReverse(handle)) {
+                const id = nodeId(handle);
+                let text = `S\t${id}\t${this.record(handle).sequence}\n`;
+                for (const [fromReverse, toId, toReverse] of this.canonicalEdges(id)) {
+                    text += `L\t${id}\t${fromReverse ? '-' : '+'}\t${toId}\t${toReverse ? '-' : '+'}\n`;
+                }
+                chunks.push(encoder.encode(text));
+            }
+        }
+        return sha256Hex(chunks);
+    }
+    async toGFA(cigar, opts = {}) {
+        const lines = [
+            this.refPath ? `H\tVN:Z:1.1\tRS:Z:${this.refPath.sample}` : 'H\tVN:Z:1.1',
+            ...gfaHeaderLines(subgraphName(await this.stableName(), await this.db.graphName())),
+        ];
+        const handles = this.sortedHandles();
+        for (const handle of handles) {
+            if (!isReverse(handle)) {
+                lines.push(`S\t${nodeId(handle)}\t${this.record(handle).sequence}`);
+            }
+        }
+        const sign = (handle) => (isReverse(handle) ? '-' : '+');
+        for (const handle of handles) {
+            for (const successor of this.record(handle).successors()) {
+                if (this.hasHandle(successor) && edgeIsCanonical(handle, successor)) {
+                    lines.push(`L\t${nodeId(handle)}\t${sign(handle)}\t${nodeId(successor)}\t${sign(successor)}\t0M`);
+                }
+            }
+        }
+        const walk = (info, name, end, cigarString) => {
+            const steps = info.path
+                .map(handle => `${isReverse(handle) ? '<' : '>'}${nodeId(handle)}`)
+                .join('');
+            const weight = info.weight === undefined ? '' : `\tWT:i:${info.weight}`;
+            const cg = cigarString === undefined ? '' : `\tCG:Z:${cigarString}`;
+            return `W\t${name.sample}\t${name.haplotype}\t${name.contig}\t${name.fragment}\t${end}\t${steps}${weight}${cg}`;
+        };
+        const contig = this.refPath?.contig ?? 'unknown';
+        if (this.refId !== undefined && this.refPath && this.refInterval) {
+            lines.push(walk(this.paths[this.refId], {
+                ...this.refPath,
+                fragment: this.refPath.fragment + this.refInterval[0],
+            }, this.refPath.fragment + this.refInterval[1], undefined));
+        }
+        let haplotype = 1;
+        this.paths.forEach((info, index) => {
+            if (index !== this.refId) {
+                const resolved = opts.names === 'resolved' ? info.identity : undefined;
+                const cigarString = cigar ? this.alignToRef(index) : undefined;
+                lines.push(resolved
+                    ? walk(info, {
+                        ...resolved.name,
+                        fragment: resolved.name.fragment + resolved.hapStart,
+                    }, resolved.name.fragment + resolved.hapEnd, cigarString)
+                    : walk(info, { sample: 'unknown', contig, haplotype, fragment: 0 }, info.len, cigarString));
+                haplotype += 1;
+            }
+        });
+        return `${lines.join('\n')}\n`;
+    }
     toJSON(cigar, opts = {}) {
         const handles = this.sortedHandles();
         const nodes = handles
             .filter(handle => !isReverse(handle))
-            .map(handle => ({ id: String(nodeId(handle)), sequence: this.record(handle).sequence }));
+            .map(handle => ({
+            id: String(nodeId(handle)),
+            sequence: this.record(handle).sequence,
+        }));
         const edges = [];
         for (const handle of handles) {
             for (const successor of this.record(handle).successors()) {
@@ -706,7 +1025,10 @@ export class Subgraph {
         const contig = this.refPath?.contig ?? 'unknown';
         if (this.refId !== undefined && this.refPath && this.refInterval) {
             const info = this.paths[this.refId];
-            const name = { ...this.refPath, fragment: this.refPath.fragment + this.refInterval[0] };
+            const name = {
+                ...this.refPath,
+                fragment: this.refPath.fragment + this.refInterval[0],
+            };
             paths.push(jsonPath(info, formatPathName(name, this.refPath.fragment + this.refInterval[1]), undefined));
         }
         let haplotype = 1;
@@ -716,7 +1038,10 @@ export class Subgraph {
             }
             const resolved = opts.names === 'resolved' ? info.identity : undefined;
             const name = resolved
-                ? formatPathName({ ...resolved.name, fragment: resolved.name.fragment + resolved.hapStart }, resolved.name.fragment + resolved.hapEnd)
+                ? formatPathName({
+                    ...resolved.name,
+                    fragment: resolved.name.fragment + resolved.hapStart,
+                }, resolved.name.fragment + resolved.hapEnd)
                 : formatPathName({ sample: 'unknown', contig, haplotype, fragment: 0 }, info.len);
             paths.push(jsonPath(info, name, cigar ? this.alignToRef(index) : undefined));
             haplotype += 1;
@@ -729,7 +1054,10 @@ function jsonPath(info, name, cigar) {
         name,
         ...(info.weight === undefined ? {} : { weight: info.weight }),
         ...(cigar === undefined ? {} : { cigar }),
-        path: info.path.map(handle => ({ id: String(nodeId(handle)), is_reverse: isReverse(handle) })),
+        path: info.path.map(handle => ({
+            id: String(nodeId(handle)),
+            is_reverse: isReverse(handle),
+        })),
     };
 }
 function comparePaths(a, b) {
@@ -748,7 +1076,7 @@ function appendEdit(edits, op, len) {
         return;
     }
     const last = edits[edits.length - 1];
-    if (last && last[0] === op) {
+    if (last?.[0] === op) {
         last[1] += len;
     }
     else {
@@ -758,3 +1086,4 @@ function appendEdit(edits, op, len) {
 function gapPenalty(len) {
     return len === 0 ? 0 : 6 + (len - 1);
 }
+//# sourceMappingURL=subgraph.js.map