@jbrowse/cigar-utils 4.1.14

package/esm/index.js

@@ -0,0 +1,24 @@
+export { CIGAR_D, CIGAR_EQ, CIGAR_H, CIGAR_I, CIGAR_INDEL_MASK, CIGAR_M, CIGAR_M_EQ_MASK, CIGAR_N, CIGAR_P, CIGAR_S, CIGAR_X, } from './cigarConstants.js';
+export { CHAR_FROM_CODE, SEQRET, SEQRET_NUMERIC_DECODER, } from './bamSeqDecoder.js';
+export { encodeSeqNumeric } from './bamSeqEncoder.js';
+// The BAM mismatch walk and its packed reference come from `@gmod/bam`:
+// `forEachMismatchNumeric`, `packReference`, `PackedReference`. One
+// implementation of the format's trickiest walk, in the library that owns the
+// format.
+export { flipCigar, swapIndelCigar } from './cigarReorient.js';
+export { csToCigar } from './csToCigar.js';
+export { flipCs, forEachCsMismatch, forEachCsOp } from './csOps.js';
+export { orientAlignment } from './orientAlignment.js';
+export { pafIdentity } from './pafIdentity.js';
+export { DELETION_TYPE, HARDCLIP_TYPE, INSERTION_TYPE, MISMATCH_TYPE, SKIP_TYPE, SOFTCLIP_TYPE, } from './mismatchCallback.js';
+export { visitCigarRenderedSegments } from './cigarRenderedSegments.js';
+export { cigarWalkBp1, cigarWalkBp2, cigarWalkRev1, cigarWalkRev2, } from './cigarWalkStart.js';
+export { cigarToMismatches2 } from './cigarToMismatches2.js';
+export { mdToMismatches2 } from './mdToMismatches2.js';
+export { getNextRefPos } from './getNextRefPos.js';
+export { numericCigarHasSkip } from './numericCigarHasSkip.js';
+export { numericCigarToString } from './numericCigarToString.js';
+export { connectionEndpointBps, readLeadingBodyDir, readLeadingBp, readTrailingBodyDir, readTrailingBp, } from './readEndpoints.js';
+export { clipLengthAtStartOfReadNumeric, featurizeSA, featurizeSAEntries, getClip, getLength, getLengthOnRef, getLengthSansClipping, getMismatches, parseCigar2, parseCigar2Typed, parseCigar, splitSA, } from './mismatchParser.js';
+export { buildReadVsRefFeatures } from './buildReadVsRefFeatures.js';
+export { SAM_FLAG_DUPLICATE, SAM_FLAG_FAILS_QC, SAM_FLAG_FIRST_IN_PAIR, SAM_FLAG_MATE_REVERSE, SAM_FLAG_MATE_UNMAPPED, SAM_FLAG_PAIRED, SAM_FLAG_PROPER_PAIR, SAM_FLAG_REVERSE, SAM_FLAG_SECONDARY, SAM_FLAG_SECOND_IN_PAIR, SAM_FLAG_SUPPLEMENTARY, SAM_FLAG_UNMAPPED, samFlagDescriptions, samFlagLabels, samFlagNames, } from './samFlags.js';

package/esm/mdToMismatches2.d.ts

@@ -0,0 +1,2 @@
+import type { Mismatch } from './mismatchTypes.ts';
+export declare function mdToMismatches2(mdstring: string, ops: ArrayLike<number> | undefined, cigarMismatches: Mismatch[], seq: string, qual?: Uint8Array): Mismatch[];

package/esm/mdToMismatches2.js

@@ -0,0 +1,108 @@
+import { CIGAR_D, CIGAR_H, CIGAR_I, CIGAR_N, CIGAR_P, CIGAR_S, } from './cigarConstants.js';
+// Handles packed NUMERIC_CIGAR format from @gmod/bam
+// Format: Uint32Array where each value is (length << 4) | opIndex
+// opIndex is 0-8: M=0, I=1, D=2, N=3, S=4, H=5, P=6, ==7, X=8
+export function mdToMismatches2(mdstring, ops, cigarMismatches, seq, qual) {
+    if (!ops) {
+        return [];
+    }
+    const mismatchRecords = [];
+    const opsLength = ops.length;
+    const seqLength = seq.length;
+    const hasQual = qual !== undefined;
+    // only check for skips if cigarMismatches has any
+    const cigarLength = cigarMismatches.length;
+    let hasSkips = false;
+    for (let k = 0; k < cigarLength; k++) {
+        if (cigarMismatches[k].type === 'skip') {
+            hasSkips = true;
+            break;
+        }
+    }
+    let currStart = 0;
+    let lastCigar = 0;
+    let lastTemplateOffset = 0;
+    let lastRefOffset = 0;
+    let lastSkipPos = 0;
+    // parse the MD string manually for better performance
+    let i = 0;
+    const len = mdstring.length;
+    while (i < len) {
+        const char = mdstring.charCodeAt(i);
+        if (char >= 48 && char <= 57) {
+            // digit (0-9)
+            let num = 0;
+            while (i < len) {
+                const c = mdstring.charCodeAt(i);
+                if (c >= 48 && c <= 57) {
+                    num = num * 10 + (c - 48);
+                    i++;
+                }
+                else {
+                    break;
+                }
+            }
+            currStart += num;
+        }
+        else if (char === 94) {
+            // '^' - deletion
+            i++;
+            while (i < len && mdstring.charCodeAt(i) >= 65) {
+                // skip deleted bases (A-Z, a-z)
+                i++;
+                currStart++;
+            }
+        }
+        else if (char >= 65) {
+            // letter (mismatch)
+            const letter = mdstring[i];
+            i++;
+            // handle skips in cigar
+            if (hasSkips && cigarLength > 0) {
+                for (let k = lastSkipPos; k < cigarLength; k++) {
+                    const mismatch = cigarMismatches[k];
+                    if (mismatch.type === 'skip' && currStart >= mismatch.start) {
+                        currStart += mismatch.length;
+                        lastSkipPos = k + 1;
+                    }
+                }
+            }
+            // find position in read that corresponds to currStart
+            let templateOffset = lastTemplateOffset;
+            let refOffset = lastRefOffset;
+            // Packed format: each element is (length << 4) | opIndex
+            for (let j = lastCigar; j < opsLength && refOffset <= currStart; j++, lastCigar = j) {
+                const packed = ops[j];
+                const len = packed >>> 4;
+                const op = packed & 0xf;
+                if (op === CIGAR_S || op === CIGAR_I) {
+                    templateOffset += len;
+                }
+                else if (op === CIGAR_D || op === CIGAR_P || op === CIGAR_N) {
+                    refOffset += len;
+                }
+                else if (op !== CIGAR_H) {
+                    templateOffset += len;
+                    refOffset += len;
+                }
+            }
+            lastTemplateOffset = templateOffset;
+            lastRefOffset = refOffset;
+            const s = templateOffset - (refOffset - currStart);
+            const base = s < seqLength ? seq[s] : 'X';
+            mismatchRecords.push({
+                start: currStart,
+                base,
+                qual: hasQual ? qual[s] : undefined,
+                altbase: letter,
+                length: 1,
+                type: 'mismatch',
+            });
+            currStart++;
+        }
+        else {
+            i++;
+        }
+    }
+    return mismatchRecords;
+}

package/esm/mismatchCallback.d.ts

@@ -0,0 +1,29 @@
+export declare const MISMATCH_TYPE = 88;
+export declare const INSERTION_TYPE = 73;
+export declare const DELETION_TYPE = 68;
+export declare const SKIP_TYPE = 78;
+export declare const SOFTCLIP_TYPE = 83;
+export declare const HARDCLIP_TYPE = 72;
+/**
+ * Identical to `@gmod/bam`'s and `@gmod/cram`'s `MismatchCallback`, so a
+ * consumer's callback goes straight to either walk with nothing in between.
+ *
+ * The last three are numbers rather than `number | undefined`: an absent
+ * quality is -1, and an absent reference base or clip length is 0. That is
+ * what both libraries emit, and it saves every consumer a non-null assertion.
+ */
+export type MismatchCallback = (type: number, start: number, length: number, base: string, qual: number, altbase: number, cliplen: number) => void;
+/**
+ * The genomic viewport a `forEachMismatch` walk reports within: 0-based
+ * half-open, and absolute even where the walk reports read-relative positions,
+ * since it describes a region of the reference rather than a position in the
+ * output.
+ *
+ * The narrow half of `@gmod/bam`'s and `@gmod/cram`'s `MismatchOptions` — the
+ * part every alignment feature can honour, without this package having to know
+ * about a packed reference or an origin.
+ */
+export interface MismatchWindow {
+    start?: number;
+    end?: number;
+}

package/esm/mismatchCallback.js

@@ -0,0 +1,20 @@
+// Shared types for callback-based mismatch iteration
+// Each adapter implements forEachMismatch using its optimal internal structure
+//
+// The values are the ASCII codes of the CIGAR/CRAM letters they name, which is
+// what lets `@gmod/cram`'s own forEachMismatch emit straight into one of these
+// callbacks: it reports a difference by its CRAM feature code, so a CRAM
+// adapter that agrees on the numbering needs no translating callback in
+// between, and that indirect call was 17% of the walk. See @gmod/cram ADR 0008
+// and CramSlightlyLazyFeature.forEachMismatch. `cramCodes.test.ts` pins the
+// agreement.
+//
+// Nothing depends on them being 0..5 — every consumer compares symbolically
+// and none of them is serialized — but do not renumber them without checking
+// that again.
+export const MISMATCH_TYPE = 0x58; // 'X'
+export const INSERTION_TYPE = 0x49; // 'I'
+export const DELETION_TYPE = 0x44; // 'D'
+export const SKIP_TYPE = 0x4e; // 'N'
+export const SOFTCLIP_TYPE = 0x53; // 'S'
+export const HARDCLIP_TYPE = 0x48; // 'H'

package/esm/mismatchParser.d.ts

@@ -0,0 +1,79 @@
+/**
+ * #api
+ * Parses a CIGAR string to an alternating `[length, op, ...]` string array.
+ */
+export declare function parseCigar(s?: string): string[];
+/**
+ * #api
+ * Parses a CIGAR string to a packed number array where each value is
+ * `(length << 4) | opIndex`.
+ */
+export declare function parseCigar2(s?: string): number[];
+/**
+ * #api
+ * Same encoding as `parseCigar2` but writes into a packed `Uint32Array` —
+ * matches the NUMERIC_CIGAR format that BAM/CRAM adapters emit, so consumers can
+ * use a single typed-array code path.
+ */
+export declare function parseCigar2Typed(s?: string): Uint32Array<ArrayBuffer>;
+/**
+ * #api
+ * Computes the list of mismatches (SNVs, indels, clips, skips) for a read from
+ * its CIGAR, optional MD tag, sequence, reference, and quality.
+ */
+export declare function getMismatches(cigar?: string, md?: string, seq?: string, ref?: string, qual?: Uint8Array): import("./mismatchTypes.ts").Mismatch[];
+/**
+ * #api
+ * Length the read spans on the reference (sum of M/=/X/D/N ops).
+ */
+export declare function getLengthOnRef(cigar: string): number;
+/**
+ * #api
+ * Length of the read sequence (sum of all ops except D/N).
+ */
+export declare function getLength(cigar: string): number;
+export declare function getLengthSansClipping(cigar: string): number;
+export declare function getClip(cigar: string, strand: number): number;
+export declare function clipLengthAtStartOfReadNumeric(cigar: ArrayLike<number>, strand: number): number;
+export declare function featurizeSA(SA: string | undefined, id: string, strand: number | undefined, readName: string | undefined, normalize?: boolean): {
+    refName: string;
+    start: number;
+    end: number;
+    seqLength: number;
+    clipLengthAtStartOfRead: number;
+    CIGAR: string;
+    strand: -1 | 1;
+    uniqueId: string;
+    mate: {
+        start: number;
+        end: number;
+        refName: string | undefined;
+    };
+}[];
+/**
+ * #api
+ * The `;`-separated alignment records of an SA tag, empties dropped — the input
+ * `featurizeSAEntries` expects.
+ */
+export declare function splitSA(SA: string): string[];
+/**
+ * #api
+ * featurizeSA over pre-split entries (see splitSA). Lets a caller filter the
+ * entries first — e.g. deduplicating the records repeated across a split read's
+ * segments — without paying to split and rejoin the tag around the filter.
+ */
+export declare function featurizeSAEntries(entries: string[], id: string, strand: number | undefined, readName: string | undefined, normalize?: boolean): {
+    refName: string;
+    start: number;
+    end: number;
+    seqLength: number;
+    clipLengthAtStartOfRead: number;
+    CIGAR: string;
+    strand: -1 | 1;
+    uniqueId: string;
+    mate: {
+        start: number;
+        end: number;
+        refName: string | undefined;
+    };
+}[];

package/esm/mismatchParser.js

@@ -0,0 +1,238 @@
+import { CIGAR_D, CIGAR_H, CIGAR_I, CIGAR_N, CIGAR_S, } from './cigarConstants.js';
+import { cigarToMismatches2 } from './cigarToMismatches2.js';
+import { mdToMismatches2 } from './mdToMismatches2.js';
+// CIGAR operation char codes to indices (from BAM spec)
+const CIGAR_CODE_TO_INDEX = {
+    77: 0, // M
+    73: 1, // I
+    68: 2, // D
+    78: 3, // N
+    83: 4, // S
+    72: 5, // H
+    80: 6, // P
+    61: 7, // =
+    88: 8, // X
+};
+/**
+ * #api
+ * Parses a CIGAR string to an alternating `[length, op, ...]` string array.
+ */
+export function parseCigar(s = '') {
+    let currLen = '';
+    const ret = [];
+    for (let i = 0, l = s.length; i < l; i++) {
+        const c = s[i];
+        if (c >= '0' && c <= '9') {
+            currLen = currLen + c;
+        }
+        else {
+            ret.push(currLen, c);
+            currLen = '';
+        }
+    }
+    return ret;
+}
+/**
+ * #api
+ * Parses a CIGAR string to a packed number array where each value is
+ * `(length << 4) | opIndex`.
+ */
+export function parseCigar2(s = '') {
+    let currLen = 0;
+    const ret = [];
+    for (let i = 0, l = s.length; i < l; i++) {
+        const code = s.charCodeAt(i);
+        if (code >= 48 && code <= 57) {
+            currLen = currLen * 10 + (code - 48);
+        }
+        else {
+            const opIndex = CIGAR_CODE_TO_INDEX[code];
+            ret.push((currLen << 4) | opIndex);
+            currLen = 0;
+        }
+    }
+    return ret;
+}
+/**
+ * #api
+ * Same encoding as `parseCigar2` but writes into a packed `Uint32Array` —
+ * matches the NUMERIC_CIGAR format that BAM/CRAM adapters emit, so consumers can
+ * use a single typed-array code path.
+ */
+export function parseCigar2Typed(s = '') {
+    let opCount = 0;
+    for (let i = 0, l = s.length; i < l; i++) {
+        const code = s.charCodeAt(i);
+        if (code < 48 || code > 57) {
+            opCount++;
+        }
+    }
+    const out = new Uint32Array(opCount);
+    let currLen = 0;
+    let j = 0;
+    for (let i = 0, l = s.length; i < l; i++) {
+        const code = s.charCodeAt(i);
+        if (code >= 48 && code <= 57) {
+            currLen = currLen * 10 + (code - 48);
+        }
+        else {
+            out[j++] = (currLen << 4) | CIGAR_CODE_TO_INDEX[code];
+            currLen = 0;
+        }
+    }
+    return out;
+}
+/**
+ * #api
+ * Computes the list of mismatches (SNVs, indels, clips, skips) for a read from
+ * its CIGAR, optional MD tag, sequence, reference, and quality.
+ */
+export function getMismatches(cigar, md, seq, ref, qual) {
+    const ops = parseCigar2(cigar);
+    const mismatches = cigar ? cigarToMismatches2(ops, seq, ref, qual) : [];
+    if (md && seq) {
+        return mismatches.concat(mdToMismatches2(md, ops, mismatches, seq, qual));
+    }
+    return mismatches;
+}
+// All three lengths in one pass over already-parsed ops: callers that want more
+// than one (featurizeSA wants all three) would otherwise re-scan and re-allocate
+// the op array per length.
+function cigarLengths(ops) {
+    let lengthOnRef = 0;
+    let length = 0;
+    let lengthSansClipping = 0;
+    for (let i = 0, l = ops.length; i < l; i++) {
+        const op = ops[i];
+        const opIdx = op & 0xf;
+        const len = op >>> 4;
+        const clipping = opIdx === CIGAR_H || opIdx === CIGAR_S;
+        const refOnly = opIdx === CIGAR_D || opIdx === CIGAR_N;
+        if (!clipping && opIdx !== CIGAR_I) {
+            lengthOnRef += len;
+        }
+        if (!refOnly) {
+            length += len;
+        }
+        if (!clipping && !refOnly) {
+            lengthSansClipping += len;
+        }
+    }
+    return { lengthOnRef, length, lengthSansClipping };
+}
+/**
+ * #api
+ * Length the read spans on the reference (sum of M/=/X/D/N ops).
+ */
+export function getLengthOnRef(cigar) {
+    return cigarLengths(parseCigar2(cigar)).lengthOnRef;
+}
+/**
+ * #api
+ * Length of the read sequence (sum of all ops except D/N).
+ */
+export function getLength(cigar) {
+    return cigarLengths(parseCigar2(cigar)).length;
+}
+export function getLengthSansClipping(cigar) {
+    return cigarLengths(parseCigar2(cigar)).lengthSansClipping;
+}
+// clip at the end of the CIGAR string = start of a reverse-strand read,
+// clip at the start of the CIGAR string = start of a forward-strand read
+export function getClip(cigar, strand) {
+    if (!cigar) {
+        return 0;
+    }
+    if (strand === -1) {
+        const last = cigar.length - 1;
+        const op = cigar[last];
+        if (op === 'S' || op === 'H') {
+            let i = last;
+            while (i > 0 && cigar[i - 1] >= '0' && cigar[i - 1] <= '9') {
+                i--;
+            }
+            return +cigar.slice(i, last);
+        }
+        return 0;
+    }
+    else {
+        let i = 0;
+        while (cigar[i] >= '0' && cigar[i] <= '9') {
+            i++;
+        }
+        const op = cigar[i];
+        return (op === 'S' || op === 'H') && i > 0 ? +cigar.slice(0, i) : 0;
+    }
+}
+// numeric analog of getClip: reads the start-clip length straight off a packed
+// NUMERIC_CIGAR (each entry = (length << 4) | opIndex) without serializing to a
+// CIGAR string. Reverse-strand reads clip at the CIGAR tail, forward at the head.
+export function clipLengthAtStartOfReadNumeric(cigar, strand) {
+    const len = cigar.length;
+    if (len === 0) {
+        return 0;
+    }
+    const packed = strand === -1 ? cigar[len - 1] : cigar[0];
+    const op = packed & 0xf;
+    return op === CIGAR_S || op === CIGAR_H ? packed >>> 4 : 0;
+}
+// produces a list of "feature-like" object from parsing supplementary
+// alignments in the SA tag
+//
+// @param normalize - used specifically in the linear-read-vs-ref context, it
+// flips features around relative to the original feature. other contexts of
+// usage can keep this false
+export function featurizeSA(SA, id, strand, readName, normalize) {
+    return SA === undefined
+        ? []
+        : featurizeSAEntries(splitSA(SA), id, strand, readName, normalize);
+}
+/**
+ * #api
+ * The `;`-separated alignment records of an SA tag, empties dropped — the input
+ * `featurizeSAEntries` expects.
+ */
+export function splitSA(SA) {
+    return SA.split(';').filter(aln => !!aln);
+}
+/**
+ * #api
+ * featurizeSA over pre-split entries (see splitSA). Lets a caller filter the
+ * entries first — e.g. deduplicating the records repeated across a split read's
+ * segments — without paying to split and rejoin the tag around the filter.
+ */
+export function featurizeSAEntries(entries, id, strand, readName, normalize) {
+    const strandNum = strand ?? 1;
+    return entries.map((aln, index) => {
+        const ret = aln.split(',');
+        const saRef = ret[0];
+        const saStart = ret[1];
+        const saStrand = ret[2];
+        const saCigar = ret[3];
+        const saOps = parseCigar2(saCigar);
+        const { lengthOnRef: saLengthOnRef, length: saLength, lengthSansClipping: saLengthSansClipping, } = cigarLengths(saOps);
+        const saStrandNormalized = saStrand === '-' ? -1 : 1;
+        const effectiveStrand = normalize
+            ? strandNum === saStrandNormalized
+                ? 1
+                : -1
+            : saStrandNormalized;
+        const saClipPos = clipLengthAtStartOfReadNumeric(saOps, effectiveStrand);
+        const saRealStart = +saStart - 1;
+        return {
+            refName: saRef,
+            start: saRealStart,
+            end: saRealStart + saLengthOnRef,
+            seqLength: saLength,
+            clipLengthAtStartOfRead: saClipPos,
+            CIGAR: saCigar,
+            strand: effectiveStrand,
+            uniqueId: `${id}_SA${index}`,
+            mate: {
+                start: saClipPos,
+                end: saClipPos + saLengthSansClipping,
+                refName: readName,
+            },
+        };
+    });
+}

package/esm/mismatchTypes.d.ts

@@ -0,0 +1,27 @@
+interface BaseMismatch {
+    start: number;
+    length: number;
+}
+export interface SNPMismatch extends BaseMismatch {
+    type: 'mismatch';
+    base: string;
+    qual?: number;
+    altbase?: string;
+}
+export interface InsertionMismatch extends BaseMismatch {
+    type: 'insertion';
+    insertlen: number;
+    insertedBases?: string;
+}
+export interface DeletionMismatch extends BaseMismatch {
+    type: 'deletion';
+}
+export interface SkipMismatch extends BaseMismatch {
+    type: 'skip';
+}
+export interface ClipMismatch extends BaseMismatch {
+    type: 'softclip' | 'hardclip';
+    cliplen: number;
+}
+export type Mismatch = SNPMismatch | InsertionMismatch | DeletionMismatch | SkipMismatch | ClipMismatch;
+export {};

package/esm/mismatchTypes.js

@@ -0,0 +1 @@
+export {};

package/esm/numericCigarHasSkip.d.ts

@@ -0,0 +1 @@
+export declare function numericCigarHasSkip(cigar: ArrayLike<number>): boolean;

package/esm/numericCigarHasSkip.js

@@ -0,0 +1,11 @@
+import { CIGAR_N } from './cigarConstants.js';
+// Whether a packed CIGAR (`len << 4 | op`) carries a reference skip — the `N`
+// a spliced aligner writes across an intron.
+export function numericCigarHasSkip(cigar) {
+    for (let i = 0; i < cigar.length; i++) {
+        if ((cigar[i] & 0xf) === CIGAR_N) {
+            return true;
+        }
+    }
+    return false;
+}

package/esm/numericCigarToString.d.ts

@@ -0,0 +1 @@
+export declare function numericCigarToString(cigar: ArrayLike<number>): string;

package/esm/numericCigarToString.js

@@ -0,0 +1,13 @@
+// Packed CIGAR op index (packed & 0xf) to op char, indices per BAM spec:
+// M=0 I=1 D=2 N=3 S=4 H=5 P=6 ==7 X=8
+const CIGAR_CHARS = 'MIDNSHP=X';
+// serialize a packed NUMERIC_CIGAR (each entry = (length << 4) | opIndex) back
+// to a CIGAR string; inverse of the numeric packing produced across adapters
+export function numericCigarToString(cigar) {
+    let result = '';
+    for (let i = 0, l = cigar.length; i < l; i++) {
+        const packed = cigar[i];
+        result += (packed >>> 4) + CIGAR_CHARS[packed & 0xf];
+    }
+    return result;
+}

package/esm/orientAlignment.d.ts

@@ -0,0 +1,9 @@
+export declare function orientAlignment({ cg, cs, flip, strand, }: {
+    cg: string | undefined;
+    cs: string | undefined;
+    flip: boolean;
+    strand: number;
+}): {
+    CIGAR: string | undefined;
+    cs: string | undefined;
+};

package/esm/orientAlignment.js

@@ -0,0 +1,26 @@
+import { flipCigar, swapIndelCigar } from './cigarReorient.js';
+import { flipCs } from './csOps.js';
+import { csToCigar } from './csToCigar.js';
+// Resolve a PAF row's alignment detail into the perspective the view is anchored
+// on. `flip` is set when viewing the query assembly. A cg CIGAR is used when
+// present, otherwise one is derived from cs. cs (real per-base diffs) maps
+// directly in the target perspective; in the query perspective it is flipped,
+// except reverse-strand which additionally needs a reverse-complement we don't
+// do — there cs is dropped and the flipped CIGAR carries mismatch positions.
+// flipCs drops it too when the row states an intron, which is a reference gap
+// that the query perspective has no way to write.
+export function orientAlignment({ cg, cs, flip, strand, }) {
+    let CIGAR = cg ?? (cs ? csToCigar(cs) : undefined);
+    let orientedCs = cs;
+    if (CIGAR && flip) {
+        if (strand === -1) {
+            CIGAR = flipCigar(CIGAR);
+            orientedCs = undefined;
+        }
+        else {
+            CIGAR = swapIndelCigar(CIGAR);
+            orientedCs = cs ? flipCs(cs) : undefined;
+        }
+    }
+    return { CIGAR, cs: orientedCs };
+}

package/esm/pafIdentity.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Identity in [0,1] for one PAF row, from whichever of its tags/columns carries
+ * it. Prefers the `de:f:` tag (minimap2 gap-compressed divergence) since it is
+ * computed from the actual CIGAR — the same quantity rustybam's `rb stats --paf`
+ * writes and SVbyEye computes per-bin. Falls back to odgi untangle's `id:f:` tag
+ * (a percentage or a fraction), then to residue matches over block length.
+ *
+ * Lives here, in a package with no framework deps, because two independent
+ * pieces of code must agree on it to the digit: the synteny adapters read it at
+ * render time, and `jbrowse make-pif` writes the coarse LOD tier's `de:f:` as
+ * `1 - pafIdentity(row)`. If the two chains diverge on any rung, identity
+ * coloring jumps at the zoom where the view switches tiers — which is exactly
+ * what happened when make-pif's copy skipped the `id:f:` rung.
+ */
+export declare function pafIdentity(row: {
+    de?: string | number;
+    id?: string | number;
+    numMatches?: string | number;
+    blockLen?: string | number;
+}): number;

package/esm/pafIdentity.js

@@ -0,0 +1,31 @@
+/**
+ * Identity in [0,1] for one PAF row, from whichever of its tags/columns carries
+ * it. Prefers the `de:f:` tag (minimap2 gap-compressed divergence) since it is
+ * computed from the actual CIGAR — the same quantity rustybam's `rb stats --paf`
+ * writes and SVbyEye computes per-bin. Falls back to odgi untangle's `id:f:` tag
+ * (a percentage or a fraction), then to residue matches over block length.
+ *
+ * Lives here, in a package with no framework deps, because two independent
+ * pieces of code must agree on it to the digit: the synteny adapters read it at
+ * render time, and `jbrowse make-pif` writes the coarse LOD tier's `de:f:` as
+ * `1 - pafIdentity(row)`. If the two chains diverge on any rung, identity
+ * coloring jumps at the zoom where the view switches tiers — which is exactly
+ * what happened when make-pif's copy skipped the `id:f:` rung.
+ */
+export function pafIdentity(row) {
+    if (row.de !== undefined) {
+        const d = +row.de;
+        if (Number.isFinite(d) && d >= 0 && d <= 1) {
+            return 1 - d;
+        }
+    }
+    if (row.id !== undefined) {
+        const v = +row.id;
+        if (Number.isFinite(v)) {
+            return v > 1 ? v / 100 : v;
+        }
+    }
+    const matches = +(row.numMatches ?? 0);
+    const blockLen = +(row.blockLen ?? 0);
+    return blockLen > 0 ? matches / blockLen : 0;
+}