@jbrowse/bandage-core 10.3.1 → 11.1.0

package/README.md

@@ -10,6 +10,11 @@ npm install @jbrowse/bandage-core
 
 - GFA and rGFA text in (`loadGraph`), or the same graph as typed arrays a worker
   can transfer (`GraphTables`)
+- A walk-file cut's W lines tag what lies past each fragment's start and end as
+  `ws:Z:`/`we:Z:`, such as `break,bp=19021` or
+  `elsewhere,trimmed=400,chunk=GRCh38#0#chr22:20316160`
+  (`src/gfa/walkStops.ts`). Walk rows split each gap by those stops into parts
+  that name their cause
 - Layouts: Bandage's FMMM engine as WASM from
   [@jbrowse/graph-fmmm-layout](https://github.com/GMOD/graph-fmmm-layout)
   (`loadBandage`, `forceLayout`), ordered, anchored, sample rows, walk rows,

package/dist/chunks/{chunk-DBLV7PGG.js → chunk-3XSRT7RQ.js}

@@ -1,3 +1,8 @@
+import {
+  stopAt,
+  stopFields,
+  walkStopTags
+} from "./chunk-EIY2SKD3.js";
 import {
   PathVisits
 } from "./chunk-ZPZ7GNBT.js";
@@ -209,7 +214,16 @@ function graphFromTables({ nodes: n, links: l, walks: w }, name = "Imported GFA"
       }
       prev = node;
     }
-    paths.push({ name: pathName, nodeIds, start, ...fields });
+    paths.push({
+      name: pathName,
+      nodeIds,
+      start,
+      ...fields,
+      ...fields ? stopFields(
+        w.before && stopAt(w.before, p),
+        w.after && stopAt(w.after, p)
+      ) : {}
+    });
     anchorPaths.push({
       name: visitName,
       sample: visitSample,
@@ -272,7 +286,7 @@ function graphTablesGFA({ nodes, links, walks }) {
       steps.push([names[walks.steps[s]], walks.reversed[s]]);
     }
     lines.push(
-      fields ? `W	${fields.sample}	${fields.haplotype}	${fields.contig}	${start}	${end}	${steps.map(([id, rev]) => (rev ? "<" : ">") + id).join("")}` : `P	${pLineName(name, start, end)}	${steps.map(([id, rev]) => id + (rev ? "-" : "+")).join(",")}	*`
+      fields ? `W	${fields.sample}	${fields.haplotype}	${fields.contig}	${start}	${end}	${steps.map(([id, rev]) => (rev ? "<" : ">") + id).join("")}${walkStopTags(walks, p)}` : `P	${pLineName(name, start, end)}	${steps.map(([id, rev]) => id + (rev ? "-" : "+")).join(",")}	*`
     );
   }
   return lines.join("\n");

package/dist/chunks/{chunk-BS6HPYCZ.js → chunk-77EGQQJU.js}

@@ -50,6 +50,7 @@ function genePins(graph, genes, positions) {
       nodeIds.add(node.id);
       covered += Math.min(nodeEnd, gene.end) - Math.max(nodeStart, gene.start);
       const nodeParts = [];
+      const stretches = [];
       for (const exon of gene.exons) {
         const a = Math.max(exon.start, nodeStart);
         const b = Math.min(exon.end, nodeEnd);
@@ -65,10 +66,11 @@ function genePins(graph, genes, positions) {
           stretch.push({ ...stretch[0] });
         }
         nodeParts.push(svgPath(stretch));
+        stretches.push(stretch);
       }
       if (nodeParts.length > 0) {
         parts.push(...nodeParts);
-        exonsByNode.push({ nodeId: node.id, d: nodeParts.join("") });
+        exonsByNode.push({ nodeId: node.id, d: nodeParts.join(""), stretches });
       }
       const pinBp = Math.min(Math.max(mid, nodeStart), nodeEnd);
       const distance = Math.abs(pinBp - mid);

package/dist/chunks/chunk-7BTO7MZS.js

@@ -0,0 +1,46 @@
+import {
+  genesFromText
+} from "./chunk-G6UIYQZR.js";
+import {
+  featuresOnBackbone,
+  graphBackbone,
+  refNameBinding
+} from "./chunk-234NFZS4.js";
+
+// src/genes/backboneGenes.ts
+async function backboneGenes(graph, source) {
+  const backbone = graphBackbone(graph);
+  if (!backbone) {
+    return { genes: [] };
+  }
+  const bind = refNameBinding(
+    backbone.contigs.map((c) => c.refName),
+    source.refNames
+  );
+  let names;
+  let features;
+  if ("indexed" in source) {
+    names = await source.indexed.getReferenceSequenceNames();
+    const lines = [];
+    for (const contig of backbone.contigs) {
+      const name = names.find((n) => bind(n) === contig.refName);
+      if (name !== void 0) {
+        await source.indexed.getLines(name, contig.start, contig.end, {
+          lineCallback: (line) => lines.push(line)
+        });
+      }
+    }
+    features = genesFromText(lines.join("\n"), source.format);
+  } else {
+    features = genesFromText(source.text, source.format);
+    names = [...new Set(features.map((f) => f.refName))];
+  }
+  return {
+    genes: featuresOnBackbone(features, backbone, source.refNames),
+    unbound: names.some((name) => bind(name) !== void 0) ? void 0 : { names, contigs: backbone.contigs.map((c) => c.contig) }
+  };
+}
+
+export {
+  backboneGenes
+};

package/dist/chunks/{chunk-BKEZLETL.js → chunk-AI5PTOSV.js}

@@ -1,6 +1,6 @@
 import {
   clampZoom
-} from "./chunk-KMBE2Q42.js";
+} from "./chunk-KDU4EF66.js";
 
 // src/viewport.ts
 function axisScaleOf(scale, pixelRows) {

package/dist/chunks/{chunk-CGFPFBT2.js → chunk-D4ZFRBB4.js}

@@ -1,3 +1,7 @@
+import {
+  GAP_CAUSE_TEXT,
+  OUTSIDE_TEXT
+} from "./chunk-EIY2SKD3.js";
 import {
   formatBp,
   groupDigits
@@ -14,10 +18,15 @@ function walkKey(walk, reference) {
   const own = walk.range ? rangeText(walk.range.contig, walk.range.start, walk.range.end) : void 0;
   const scale = field === "progress" ? own : field === "reference" && reference ? rangeText(reference.name, reference.start, reference.end) : void 0;
   const spanned = walk.range ? walk.range.end - walk.range.start : walk.bp;
-  const outside = spanned - walk.bp;
+  const outside = spanned - walk.bp - walk.missingBp - walk.unknownBp;
+  const gaps = [
+    [walk.missingBp, GAP_CAUSE_TEXT.missing],
+    [walk.unknownBp, GAP_CAUSE_TEXT.unknown],
+    [outside, OUTSIDE_TEXT]
+  ];
   return {
     delta: walk.referenceBp === void 0 || spanned === walk.referenceBp ? "" : ` ${spanned > walk.referenceBp ? "+" : "\u2212"}${formatBp(Math.abs(spanned - walk.referenceBp))}`,
-    outside: outside > 0 ? `, ${formatBp(outside)} outside the cut` : "",
+    gaps: gaps.filter(([bp]) => bp > 0).map(([bp, text]) => `, ${formatBp(bp)} ${text}`).join(""),
     reversed: walk.reversedBp > 0 ? `, ${formatBp(walk.reversedBp)} reversed` : "",
     shades: field !== "walk",
     scale,

package/dist/chunks/{chunk-OOIOX36I.js → chunk-DEDD7TFJ.js}

@@ -1,6 +1,9 @@
 import {
   pathOrigin
 } from "./chunk-B5X2RLJG.js";
+import {
+  gapParts
+} from "./chunk-EIY2SKD3.js";
 import {
   groupBy
 } from "./chunk-BSOZW3FC.js";
@@ -19,6 +22,7 @@ function labelOf(path) {
 var NodeTable = class {
   constructor(graph) {
     this.index = /* @__PURE__ */ new Map();
+    this.ids = [];
     this.lengths = [];
     this.onReference = new Uint8Array(0);
     this.referenceStart = new Float64Array(0);
@@ -32,6 +36,7 @@ var NodeTable = class {
     if (i === void 0) {
       i = this.lengths.length;
       this.index.set(id, i);
+      this.ids.push(id);
       this.lengths.push(0);
     }
     return i;
@@ -50,10 +55,13 @@ var NodeTable = class {
 };
 function stepsOf(pieces, table) {
   const out = [];
+  const gaps = [];
   let end;
+  let previous;
   for (const piece of pieces) {
     if (end !== void 0 && piece.start !== void 0 && piece.start > end) {
-      out.push(end - piece.start);
+      gaps.push(gapParts(piece.start - end, previous?.after, piece.before));
+      out.push(-gaps.length);
     }
     let bp = 0;
     for (const node of piece.nodes) {
@@ -61,8 +69,9 @@ function stepsOf(pieces, table) {
       bp += table.lengths[node];
     }
     end = piece.start === void 0 ? void 0 : piece.start + bp;
+    previous = piece;
   }
-  return Float64Array.from(out);
+  return { steps: Float64Array.from(out), gaps };
 }
 function stepSpan(pieces, table, k) {
   let end;
@@ -203,10 +212,13 @@ function walkRows(graph, region, unit) {
     const path = paths2[0];
     const pieces = paths2.map((piece, p) => ({
       start: piece.start,
-      nodes: nodes?.[p] ?? table.nodesOf(piece)
+      nodes: nodes?.[p] ?? table.nodesOf(piece),
+      before: piece.before,
+      after: piece.after
     })).sort((a, b) => (a.start ?? 0) - (b.start ?? 0));
+    const { steps, gaps } = stepsOf(pieces, table);
     const { ids, complete, from, to, stop } = sliceBetween(
-      stepsOf(pieces, table),
+      steps,
       table,
       cut,
       flanked
@@ -214,24 +226,42 @@ function walkRows(graph, region, unit) {
     const contig = path.contig ?? panSNContig(pathOrigin(path.name).name);
     const axisSpan = stepSpan(pieces, table, from < 0 ? 0 : from);
     const axis = !axisSpan ? void 0 : from < 0 ? { contig, start: axisSpan.start, reversed: false } : from < to ? { contig, start: axisSpan.end, reversed: false } : { contig, start: axisSpan.start, reversed: true };
-    const { lengths, onReference, referenceStart: referenceStart2, referenceEnd } = table;
+    const {
+      ids: nodeIds,
+      lengths,
+      onReference,
+      referenceStart: referenceStart2,
+      referenceEnd
+    } = table;
     const runs = [];
+    const visits = [];
     let last;
     let bp = 0;
     let offReferenceBp = 0;
     let gapBp = 0;
     let step = 0;
+    const backwards = from >= 0 && from > to;
     for (const node of ids) {
       if (node < 0) {
-        last = { start: bp, bp: -node, onReference: false, gap: true };
-        runs.push(last);
-        bp -= node;
-        gapBp -= node;
+        const parts = gaps[-node - 1];
+        for (const { bp: partBp, ...why } of backwards ? [...parts].reverse() : parts) {
+          last = {
+            start: bp,
+            bp: partBp,
+            onReference: false,
+            gap: true,
+            ...why
+          };
+          runs.push(last);
+          bp += partBp;
+          gapBp += partBp;
+        }
         step = 0;
         continue;
       }
       const len = lengths[node];
       const on = onReference[node] === 1;
+      visits.push({ node: nodeIds[node], start: bp, onReference: on });
       const at = last?.referenceStart;
       const forward = on && at !== void 0 && step >= 0 && at + last.bp === referenceStart2[node];
       const backward = on && at !== void 0 && step <= 0 && referenceEnd[node] === at;
@@ -270,6 +300,7 @@ function walkRows(graph, region, unit) {
       complete,
       stop,
       runs,
+      visits,
       axis
     };
   };

package/dist/chunks/{chunk-YZQI35UJ.js → chunk-DR24UTRS.js}

@@ -1,10 +1,13 @@
 import {
   encodedColor,
   resolveEncoding
-} from "./chunk-DO62DG26.js";
+} from "./chunk-TABI4JEU.js";
 import {
   pathOrigin
 } from "./chunk-B5X2RLJG.js";
+import {
+  gapParts
+} from "./chunk-EIY2SKD3.js";
 import {
   panSNContig
 } from "./chunk-4XWZNPQ2.js";
@@ -68,6 +71,22 @@ function highlightOf(graph, name, { byId, edgeAt }) {
       before += length;
     });
   }
+  let missingBp = 0;
+  let unknownBp = 0;
+  let end;
+  pieces.forEach((piece, p) => {
+    if (end !== void 0 && piece.start !== void 0 && piece.start > end) {
+      for (const part of gapParts(
+        piece.start - end,
+        pieces[p - 1].after,
+        piece.before
+      )) {
+        missingBp += part.cause === "missing" ? part.bp : 0;
+        unknownBp += part.cause === "unknown" ? part.bp : 0;
+      }
+    }
+    end = piece.start === void 0 ? void 0 : piece.start + bpOf(piece);
+  });
   const reference = isReference(graph, name);
   const referenceSpan = () => {
     const referencePieces = reference ? [] : (graph.paths ?? []).filter((p) => isReference(graph, p.name));
@@ -86,7 +105,9 @@ function highlightOf(graph, name, { byId, edgeAt }) {
     progress,
     steps: pieces.reduce((sum, piece) => sum + piece.nodeIds.length, 0),
     bp,
-    referenceBp: referenceSpan()
+    referenceBp: referenceSpan(),
+    missingBp,
+    unknownBp
   };
 }
 function laneColors(byId, walk, encoding, ramp) {

package/dist/chunks/{chunk-Z6XZWPXK.js → chunk-DZR37KXT.js}

@@ -1,3 +1,9 @@
+import {
+  END_STOP_TAG,
+  START_STOP_TAG,
+  StopColumns,
+  parseStopTag
+} from "./chunk-EIY2SKD3.js";
 import {
   Column
 } from "./chunk-ZPZ7GNBT.js";
@@ -103,6 +109,7 @@ function readWalkBody(line, from, segments, steps) {
     }
   }
   finish(i);
+  return i;
 }
 function walkFields(line) {
   const fields = [];
@@ -159,6 +166,8 @@ function gfaTables(text) {
   const walkEnds = [];
   const offsets = [0];
   const steps = stepColumns();
+  const before = new StopColumns();
+  const after = new StopColumns();
   for (const raw of lines) {
     if (raw.startsWith("L	")) {
       const [, source, strand1, target, strand2] = trimCR(raw).split("	");
@@ -174,7 +183,17 @@ function gfaTables(text) {
         names.push(`${w.sample}#${w.haplotype}#${w.contig}`);
         walkStarts.push(w.start === "*" ? 0 : +w.start);
         walkEnds.push(w.end === "*" ? -1 : +w.end);
-        readWalkBody(line, w.body, segments, steps);
+        const end = readWalkBody(line, w.body, segments, steps);
+        const tags = walkTags(line, end);
+        if (tags === void 0) {
+          return void 0;
+        }
+        if (tags.before) {
+          before.push(tags.before);
+        }
+        if (tags.after) {
+          after.push(tags.after);
+        }
         if (steps.nodes.length === offsets.at(-1)) {
           return void 0;
         }
@@ -182,6 +201,11 @@ function gfaTables(text) {
       }
     }
   }
+  if ([before.kinds.length, after.kinds.length].some(
+    (n) => n > 0 && n < names.length
+  )) {
+    return void 0;
+  }
   return {
     nodes: {
       names: segments.names,
@@ -202,8 +226,33 @@ function gfaTables(text) {
       ends: Float64Array.from(walkEnds),
       offsets: Int32Array.from(offsets),
       steps: steps.nodes.data.slice(0, steps.nodes.length),
-      reversed: steps.reversed.data.slice(0, steps.reversed.length)
+      reversed: steps.reversed.data.slice(0, steps.reversed.length),
+      ...stopColumns(names.length, before, after)
+    }
+  };
+}
+function walkTags(line, from) {
+  const out = {};
+  for (const tag of from < line.length ? line.slice(from + 1).split("	") : []) {
+    const value = tag.slice(5);
+    if (tag.startsWith(`${START_STOP_TAG}:Z:`)) {
+      out.before = parseStopTag(value);
+      if (!out.before) {
+        return void 0;
+      }
+    } else if (tag.startsWith(`${END_STOP_TAG}:Z:`)) {
+      out.after = parseStopTag(value);
+      if (!out.after) {
+        return void 0;
+      }
     }
+  }
+  return out;
+}
+function stopColumns(walks, before, after) {
+  return {
+    ...before.kinds.length === walks && walks > 0 ? { before: before.table() } : {},
+    ...after.kinds.length === walks && walks > 0 ? { after: after.table() } : {}
   };
 }
 

package/dist/chunks/chunk-EIY2SKD3.js

@@ -0,0 +1,164 @@
+// src/gfa/walkStops.ts
+var START_STOP_TAG = "ws";
+var END_STOP_TAG = "we";
+var STOP_KINDS = ["elsewhere", "break", "end"];
+var GAP_CAUSE_TEXT = {
+  missing: "not in the graph",
+  elsewhere: "on nodes filed elsewhere",
+  unknown: "gap, cause unknown"
+};
+var OUTSIDE_TEXT = "outside the extracted subgraph";
+function gapParts(bp, after, before) {
+  if (!after && !before) {
+    return [{ bp }];
+  }
+  const left = Math.min(after?.trimmed ?? 0, bp);
+  const right = Math.min(before?.trimmed ?? 0, bp - left);
+  let rest = bp - left - right;
+  const lead = after?.kind === "break" ? Math.min(after.bp, rest) : 0;
+  rest -= lead;
+  const trail = before?.kind === "break" ? Math.min(before.bp, rest) : 0;
+  rest -= trail;
+  const elsewhere = [after, before].find((s) => s?.kind === "elsewhere");
+  const parts = [
+    { bp: left },
+    { bp: lead, cause: "missing" },
+    elsewhere?.kind === "elsewhere" ? { bp: rest, cause: "elsewhere", chunk: elsewhere.chunk } : { bp: rest, cause: "unknown" },
+    { bp: trail, cause: "missing" },
+    { bp: right }
+  ];
+  return parts.filter((part) => part.bp > 0);
+}
+function stopAt(table, i) {
+  const bp = table.bp[i];
+  const ref = table.chunkRefs[i];
+  return stopOf(
+    table.kindNames[table.kinds[i]],
+    Number.isNaN(bp) ? void 0 : bp,
+    table.trimmed[i],
+    ref < 0 ? void 0 : { refName: table.chunkRefNames[ref], start: table.chunkStarts[i] }
+  );
+}
+function stopOf(kind, bp, trimmed, chunk) {
+  const cut = trimmed > 0 ? { trimmed } : {};
+  if (kind === "elsewhere" && chunk) {
+    return { kind, chunk, ...bp === void 0 ? {} : { bp }, ...cut };
+  }
+  if (kind === "break" && bp !== void 0) {
+    return { kind, bp, ...chunk ? { chunk } : {}, ...cut };
+  }
+  return kind === "end" ? { kind, ...cut } : void 0;
+}
+function stopTag(stop) {
+  const parts = [stop.kind];
+  if ("bp" in stop && stop.bp !== void 0) {
+    parts.push(`bp=${stop.bp}`);
+  }
+  if (stop.trimmed) {
+    parts.push(`trimmed=${stop.trimmed}`);
+  }
+  if ("chunk" in stop && stop.chunk) {
+    parts.push(`chunk=${stop.chunk.refName}:${stop.chunk.start}`);
+  }
+  return parts.join(",");
+}
+function parseStopTag(value) {
+  const [kind, ...fields] = value.split(",");
+  let bp;
+  let trimmed = 0;
+  let chunk;
+  for (const field of fields) {
+    if (field.startsWith("bp=")) {
+      bp = +field.slice(3);
+    } else if (field.startsWith("trimmed=")) {
+      trimmed = +field.slice(8);
+    } else if (field.startsWith("chunk=")) {
+      const at = field.lastIndexOf(":");
+      chunk = { refName: field.slice(6, at), start: +field.slice(at + 1) };
+    }
+  }
+  return stopOf(kind, bp, trimmed, chunk);
+}
+function stopFields(before, after) {
+  return {
+    ...before ? { before } : {},
+    ...after ? { after } : {}
+  };
+}
+function walkStopFields(tags) {
+  const before = tags[START_STOP_TAG];
+  const after = tags[END_STOP_TAG];
+  return stopFields(
+    typeof before === "string" ? parseStopTag(before) : void 0,
+    typeof after === "string" ? parseStopTag(after) : void 0
+  );
+}
+function walkStopTags(walks, p) {
+  const tags = [];
+  for (const [tag, table] of [
+    [START_STOP_TAG, walks.before],
+    [END_STOP_TAG, walks.after]
+  ]) {
+    const stop = table && stopAt(table, p);
+    if (stop) {
+      tags.push(`	${tag}:Z:${stopTag(stop)}`);
+    }
+  }
+  return tags.join("");
+}
+var StopColumns = class {
+  constructor() {
+    this.kinds = [];
+    this.bp = [];
+    this.trimmed = [];
+    this.chunkRefs = [];
+    this.chunkStarts = [];
+    this.chunkRefNames = [];
+    this.refIndex = /* @__PURE__ */ new Map();
+  }
+  push(stop) {
+    this.kinds.push(STOP_KINDS.indexOf(stop.kind));
+    this.bp.push("bp" in stop && stop.bp !== void 0 ? stop.bp : NaN);
+    this.trimmed.push(stop.trimmed ?? 0);
+    const chunk = "chunk" in stop ? stop.chunk : void 0;
+    if (chunk) {
+      let ref = this.refIndex.get(chunk.refName);
+      if (ref === void 0) {
+        ref = this.chunkRefNames.length;
+        this.refIndex.set(chunk.refName, ref);
+        this.chunkRefNames.push(chunk.refName);
+      }
+      this.chunkRefs.push(ref);
+      this.chunkStarts.push(chunk.start);
+    } else {
+      this.chunkRefs.push(-1);
+      this.chunkStarts.push(NaN);
+    }
+  }
+  table() {
+    return {
+      kinds: Uint8Array.from(this.kinds),
+      kindNames: [...STOP_KINDS],
+      bp: Float64Array.from(this.bp),
+      trimmed: Float64Array.from(this.trimmed),
+      chunkRefs: Int32Array.from(this.chunkRefs),
+      chunkStarts: Float64Array.from(this.chunkStarts),
+      chunkRefNames: this.chunkRefNames
+    };
+  }
+};
+
+export {
+  START_STOP_TAG,
+  END_STOP_TAG,
+  GAP_CAUSE_TEXT,
+  OUTSIDE_TEXT,
+  gapParts,
+  stopAt,
+  stopTag,
+  parseStopTag,
+  stopFields,
+  walkStopFields,
+  walkStopTags,
+  StopColumns
+};

package/dist/chunks/{chunk-NZTYV3JL.js → chunk-FFHJGWDK.js}

@@ -5,6 +5,9 @@ import {
   pathOrigin,
   surveyPaths
 } from "./chunk-B5X2RLJG.js";
+import {
+  walkStopFields
+} from "./chunk-EIY2SKD3.js";
 
 // src/gfa/gfaConverter.ts
 function surveySegments(gfaGraph, pathSteps) {
@@ -152,7 +155,8 @@ function convertGFAToGraph(gfaGraph, name = "Imported GFA") {
       start: walkStart(walk),
       sample: walk.sample,
       haplotype: walk.haplotype,
-      contig: walk.contig
+      contig: walk.contig,
+      ...walkStopFields(walk.tags)
     });
     recordPathEdges(nodeIds2, name2);
   }

package/dist/chunks/{chunk-QH2MIXBA.js → chunk-IVOK5V3H.js}

@@ -4,27 +4,27 @@ import {
 import {
   facetLifts,
   walkLift
-} from "./chunk-YZQI35UJ.js";
+} from "./chunk-DR24UTRS.js";
 import {
   walkKey
-} from "./chunk-CGFPFBT2.js";
+} from "./chunk-D4ZFRBB4.js";
 import {
   buildGeometry,
   computeReferenceRamp
 } from "./chunk-SWCULW6S.js";
 import {
   walkRowsExtent
-} from "./chunk-A2TJ5UX6.js";
+} from "./chunk-YHJ5JLBI.js";
 import {
   pathLegend,
   walkLabelsOf
 } from "./chunk-3GP3KT5L.js";
 import {
   FIGURE_DEFAULTS
-} from "./chunk-D7WIYPG3.js";
+} from "./chunk-W6EXQDV5.js";
 import {
   drawingBounds
-} from "./chunk-KMBE2Q42.js";
+} from "./chunk-KDU4EF66.js";
 import {
   referenceLabel
 } from "./chunk-234NFZS4.js";
@@ -97,7 +97,7 @@ function figureScene(graph, layout, o) {
     referenceName,
     keyText: (walk) => {
       const key = walkKey(walk, reference);
-      return { note: key.delta + key.outside + key.reversed, scale: key.scale };
+      return { note: key.delta + key.gaps + key.reversed, scale: key.scale };
     },
     contigThickness,
     nodeWidth,

package/dist/chunks/{chunk-SFP3E4RI.js → chunk-IZ6Y5D23.js}

@@ -3,14 +3,14 @@ import {
   boxesGenes,
   rowPitch,
   rowSpan
-} from "./chunk-ZJBOM73S.js";
+} from "./chunk-XZ6PQBU6.js";
 import {
   el
 } from "./chunk-H2H4Y3TV.js";
 import {
   READOUT_ROOM,
   longestBar
-} from "./chunk-A2TJ5UX6.js";
+} from "./chunk-YHJ5JLBI.js";
 import {
   pathOrigin
 } from "./chunk-B5X2RLJG.js";