@jbrowse/bandage-core 6.0.1 → 6.0.3

package/dist/chunks/chunk-6SXMCK6I.js

@@ -0,0 +1,476 @@
+import {
+  RAMP_GRADIENT_CSS,
+  RAMP_GRADIENT_STOPS,
+  rampHueCss,
+  rampStops
+} from "./chunk-CJ2EE4AF.js";
+import {
+  REFERENCE_RAMP_ALT_CSS
+} from "./chunk-PCZ4PTYC.js";
+import {
+  LABEL_CHAR_PX
+} from "./chunk-AB35TJST.js";
+import {
+  ROW_HEIGHT_PX
+} from "./chunk-CPMHA4W5.js";
+import {
+  el
+} from "./chunk-NNODIW4U.js";
+
+// src/layout/walkRowDraw.ts
+var ON_REFERENCE = "#2f8fd6";
+var OFF_REFERENCE = "#8e3fbf";
+var OUTSIDE_CUT = "#bdbdbd";
+var GENE_INK = "#1c1c22";
+var BAR_PX = 12;
+var GAP_PX = 4;
+var MIN_TILE_PX = 3;
+function kb(bp) {
+  return `${(bp / 1e3).toFixed(bp < 1e4 ? 1 : 0)} kb`;
+}
+function units(bp, unit) {
+  return unit ? ` \u2248 ${Math.round(bp / unit)} units` : "";
+}
+function walkRowReadout(row, reference, unit, call) {
+  const { bp, gapBp, complete } = row;
+  if (!reference) {
+    return `${kb(bp)}${units(bp, unit)}`;
+  }
+  const delta = bp - reference.bp;
+  const against = delta === 0 ? "" : ` (${delta > 0 ? "+" : "\u2212"}${kb(Math.abs(delta))})`;
+  const outside = gapBp > 0 ? ` \xB7 ${kb(gapBp)} outside the cut` : "";
+  const called = call ? ` \xB7 called ${kb(call.bp)}${call.spanningReads === 0 ? " \xB7 no spanning read" : ""}` : "";
+  return `${kb(bp)}${units(bp, unit)}${against}${outside}${complete ? "" : " \xB7 partial walk"}${called}`;
+}
+function readoutPlacement(text, endX, width) {
+  const x = endX + 6;
+  const fits = x + text.length * LABEL_CHAR_PX < width;
+  return fits ? { x, anchor: "start", halo: false } : { x: endX - 6, anchor: "end", halo: true };
+}
+function unitTicks(bp, unit, pxPerBp) {
+  if (unit * pxPerBp < MIN_TILE_PX) {
+    return [];
+  }
+  const ticks = [];
+  for (let k = unit; k < bp; k += unit) {
+    ticks.push(k);
+  }
+  return ticks;
+}
+function runPaint(run, ramp) {
+  if (run.gap) {
+    return { fill: OUTSIDE_CUT };
+  }
+  if (!ramp) {
+    return { fill: run.onReference ? ON_REFERENCE : OFF_REFERENCE };
+  }
+  if (run.referenceStart === void 0) {
+    return { fill: REFERENCE_RAMP_ALT_CSS };
+  }
+  const stops = rampStops({ ...run, start: run.referenceStart }, ramp);
+  return stops.length === 1 ? { fill: rampHueCss(stops[0]) } : { stops: stops.map(rampHueCss) };
+}
+function alongRow(axis, start, end) {
+  return axis.reversed ? { start: axis.start - end, end: axis.start - start } : { start: start - axis.start, end: end - axis.start };
+}
+function rowSpan(axis, bp) {
+  return axis.reversed ? { start: axis.start - bp, end: axis.start } : { start: axis.start, end: axis.start + bp };
+}
+function genesOnRow(row, genes) {
+  const contig = row.axis?.contig;
+  return genes.filter(
+    (g) => g.refName === contig || g.refName.endsWith(`#${contig}`)
+  );
+}
+function placeRowGenes(rows, byRow) {
+  const placed = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const genes = byRow.get(row.name);
+    if (!row.axis || !genes) {
+      continue;
+    }
+    const axis = row.axis;
+    const clip = ({ start, end }) => ({
+      start: Math.max(0, start),
+      end: Math.min(row.bp, end)
+    });
+    placed.set(
+      row.name,
+      genes.map((g) => ({
+        name: g.name,
+        ...clip(alongRow(axis, g.start, g.end)),
+        exons: g.exons.map((e) => clip(alongRow(axis, e.start, e.end))).filter((e) => e.end > e.start)
+      })).filter((g) => g.end > g.start).sort((a, b) => a.start - b.start)
+    );
+  }
+  return placed;
+}
+var GENE_FONT_PX = 9;
+var GENE_CHAR_PX = 5.2;
+var MIN_LETTERED_BAR_PX = 8;
+var genePad = (rowPx, barPx) => Math.min(2, (rowPx - barPx) / 2 - 1);
+function boxesGenes(rowPx, barPx) {
+  return genePad(rowPx, barPx) >= 1;
+}
+function rowGeneBoxes(genes, X, y, { rowPx = ROW_HEIGHT_PX, barPx = BAR_PX } = {}) {
+  if (!boxesGenes(rowPx, barPx)) {
+    return [];
+  }
+  const pad = genePad(rowPx, barPx);
+  const boxes = genes.map((g) => {
+    const x = X(g.start);
+    return {
+      g,
+      x,
+      w: Math.max(2, X(g.end) - x)
+    };
+  });
+  const taken = [];
+  const named = new Set(
+    (barPx >= MIN_LETTERED_BAR_PX ? [...boxes] : []).sort((a, b) => a.w - b.w).filter(({ g, x, w }) => {
+      const half = g.name.length * GENE_CHAR_PX / 2;
+      const at = [x + w / 2 - half, x + w / 2 + half];
+      if (2 * half > w + 6 || taken.some(([a, b]) => at[0] < b + 2 && at[1] > a - 2)) {
+        return false;
+      }
+      taken.push(at);
+      return true;
+    })
+  );
+  return boxes.map((box) => ({
+    name: box.g.name,
+    x: box.x,
+    y: y - barPx / 2 - pad,
+    w: box.w,
+    h: barPx + 2 * pad,
+    exons: box.g.exons.map((e) => ({
+      x: X(e.start),
+      w: Math.max(1, X(e.end) - X(e.start))
+    })),
+    label: named.has(box) ? { x: box.x + box.w / 2, y: y + 3, size: GENE_FONT_PX } : void 0
+  }));
+}
+var rowsText = (n) => `${n} row${n === 1 ? "" : "s"}`;
+function walkRowsKey(bars, o = {}) {
+  const entries = [
+    {
+      swatch: o.ramp ? { kind: "bar", fill: o.rampCss ?? RAMP_GRADIENT_CSS, ramp: true } : { kind: "bar", fill: ON_REFERENCE },
+      label: `on ${bars.reference.label}'s path`
+    },
+    {
+      swatch: {
+        kind: "bar",
+        fill: o.ramp ? REFERENCE_RAMP_ALT_CSS : OFF_REFERENCE
+      },
+      label: `off ${bars.reference.label}'s path`
+    }
+  ];
+  if ([bars.reference, ...bars.rows].some((row) => row.gapBp > 0)) {
+    entries.push({
+      swatch: { kind: "gap", fill: OUTSIDE_CUT },
+      label: "walked outside the cut"
+    });
+  }
+  if (o.genes?.crowded) {
+    entries.push({
+      swatch: { kind: "gene" },
+      label: "genes left out: too many rows to box them in",
+      note: true
+    });
+  } else if (o.genes) {
+    entries.push({
+      swatch: { kind: "gene" },
+      label: "genes, each row's own annotation"
+    });
+    if (o.genes.untracked) {
+      entries.push({
+        swatch: { kind: "gene" },
+        label: `no gene track for ${rowsText(o.genes.untracked)}`,
+        note: true
+      });
+    }
+    if (o.genes.unplaced) {
+      entries.push({
+        swatch: { kind: "gene" },
+        label: `no contig coordinates for ${rowsText(o.genes.unplaced)}`,
+        note: true
+      });
+    }
+    if (o.genes.unread) {
+      entries.push({
+        swatch: { kind: "gene" },
+        label: `genes not read for the last ${rowsText(o.genes.unread)}`,
+        note: true
+      });
+    }
+  }
+  return entries;
+}
+var CALL_TICK = "#111";
+var UNBACKED_TICK = "#9e9e9e";
+var DISAGREES = "#c62828";
+function walkRowsKeyTree(entries, x, y, idPrefix = "walk-key") {
+  let at = 0;
+  const parts = entries.flatMap((e, i) => {
+    const rampId = `${idPrefix}-ramp-${i}`;
+    const ramp = !e.note && e.swatch.kind === "bar" && e.swatch.ramp ? el(
+      "linearGradient",
+      { id: rampId },
+      ...RAMP_GRADIENT_STOPS.map(
+        (s) => el("stop", { offset: s.offset, "stop-color": s.color })
+      )
+    ) : void 0;
+    const swatch = e.note ? void 0 : e.swatch.kind === "gene" ? el("rect", {
+      x: at,
+      y: 5,
+      width: 18,
+      height: 8,
+      fill: "none",
+      stroke: GENE_INK,
+      "stroke-width": 1.5
+    }) : el("rect", {
+      x: at,
+      y: e.swatch.kind === "gap" ? 7 : 5,
+      width: 18,
+      height: e.swatch.kind === "gap" ? GAP_PX : 8,
+      rx: 2,
+      fill: ramp ? `url(#${rampId})` : e.swatch.fill
+    });
+    const text = el(
+      "text",
+      {
+        x: e.note ? at : at + 23,
+        y: 13,
+        "font-style": e.note ? "italic" : void 0,
+        fill: e.note ? "#666" : void 0
+      },
+      e.label
+    );
+    at += (e.note ? 0 : 23) + e.label.length * LABEL_CHAR_PX + 16;
+    return [ramp, swatch, text].filter((p) => p !== void 0);
+  });
+  return {
+    width: at,
+    tree: el(
+      "g",
+      {
+        transform: `translate(${x} ${y})`,
+        "font-family": "Helvetica, Arial, sans-serif",
+        "font-size": 11
+      },
+      ...parts
+    )
+  };
+}
+function coalesceRuns(runs, pxPerBp) {
+  const minBp = 1 / pxPerBp;
+  const out = [];
+  let bucket = [];
+  const flush = () => {
+    if (bucket.length === 0) {
+      return;
+    }
+    if (bucket.length === 1) {
+      out.push(bucket[0]);
+    } else {
+      let on = 0;
+      let off = 0;
+      for (const r of bucket) {
+        if (r.onReference) {
+          on += r.bp;
+        } else {
+          off += r.bp;
+        }
+      }
+      const onReference = on >= off;
+      const lead = bucket.find((r) => r.onReference === onReference);
+      out.push({
+        start: bucket[0].start,
+        bp: on + off,
+        onReference,
+        referenceStart: onReference ? lead.referenceStart : void 0,
+        ...lead.reversed ? { reversed: true } : {}
+      });
+    }
+    bucket = [];
+  };
+  let held = 0;
+  for (const run of runs) {
+    if (run.gap || run.bp >= minBp) {
+      flush();
+      held = 0;
+      out.push(run);
+      continue;
+    }
+    bucket.push(run);
+    held += run.bp;
+    if (held >= minBp) {
+      flush();
+      held = 0;
+    }
+  }
+  flush();
+  return out;
+}
+function geneTree(box, y, barPx) {
+  return el(
+    "g",
+    { class: "row-gene", "data-testid": "graph-walk-gene" },
+    el("title", {}, box.name),
+    ...box.exons.map(
+      (e) => el("rect", {
+        x: e.x,
+        y: y - barPx / 2,
+        width: e.w,
+        height: barPx,
+        fill: GENE_INK,
+        opacity: 0.35
+      })
+    ),
+    el("rect", {
+      x: box.x,
+      y: box.y,
+      width: box.w,
+      height: box.h,
+      fill: "none",
+      stroke: GENE_INK,
+      "stroke-width": 1.5
+    }),
+    box.label && el(
+      "text",
+      {
+        x: box.label.x,
+        y: box.label.y,
+        "font-family": "sans-serif",
+        "font-size": box.label.size,
+        "font-weight": 600,
+        "text-anchor": "middle",
+        fill: GENE_INK,
+        stroke: "white",
+        "stroke-width": 2.5,
+        "paint-order": "stroke"
+      },
+      box.name
+    )
+  );
+}
+function walkRowsTree(bars, frame, o = {}) {
+  const X = (bp) => bp * frame.scaleX + frame.translateX;
+  const rowPx = frame.rowPx ?? ROW_HEIGHT_PX;
+  const barPx = frame.barPx ?? BAR_PX;
+  const Y = (row) => row * rowPx * frame.scaleY + frame.translateY;
+  const { origin, unit, reference, rows } = bars;
+  const along = (offset) => X(origin + offset);
+  const prefix = o.idPrefix ?? "walkrow";
+  const rowTree = (row, i) => {
+    const y = Y(i);
+    if (y < -barPx || y > frame.height + barPx) {
+      return void 0;
+    }
+    const runs = coalesceRuns(row.runs, frame.scaleX).flatMap((run) => {
+      const paint = runPaint(run, o.ramp);
+      const h = run.gap ? Math.min(GAP_PX, barPx) : barPx;
+      const id = `${prefix}-${i}-${run.start}`;
+      const rect = el("rect", {
+        x: along(run.start),
+        y: y - h / 2,
+        width: Math.max(1, run.bp * frame.scaleX),
+        height: h,
+        fill: "stops" in paint ? `url(#${id})` : paint.fill
+      });
+      return "stops" in paint ? [
+        el(
+          "linearGradient",
+          { id },
+          ...paint.stops.map(
+            (color, k) => el("stop", {
+              offset: k / (paint.stops.length - 1),
+              "stop-color": color
+            })
+          )
+        ),
+        rect
+      ] : [rect];
+    });
+    const ticks = unit ? unitTicks(row.bp, unit, frame.scaleX).map(
+      (k) => el("line", {
+        x1: along(k),
+        x2: along(k),
+        y1: y - barPx / 2,
+        y2: y + barPx / 2,
+        stroke: "white",
+        "stroke-width": 1
+      })
+    ) : [];
+    const { call } = row;
+    const text = walkRowReadout(
+      row,
+      i === 0 ? void 0 : reference,
+      unit,
+      call
+    );
+    const at = readoutPlacement(text, along(row.bp), frame.width);
+    const readouts = frame.readouts ?? true;
+    return el(
+      "g",
+      {
+        "data-testid": i === 0 ? "graph-walk-reference" : "graph-walk-row"
+      },
+      ...runs,
+      ...ticks,
+      ...rowGeneBoxes(o.rowGenes?.get(row.name) ?? [], along, y, {
+        rowPx,
+        barPx
+      }).map((box) => geneTree(box, y, barPx)),
+      call && el("rect", {
+        "data-testid": "graph-walk-call",
+        x: along(call.bp) - 1,
+        y: y - barPx / 2 - 3,
+        width: 2,
+        height: barPx + 6,
+        fill: call.spanningReads === 0 ? UNBACKED_TICK : CALL_TICK
+      }),
+      readouts && el(
+        "text",
+        {
+          x: at.x,
+          y: y + 4,
+          "font-family": "sans-serif",
+          "font-size": 11,
+          fill: call?.agrees === false ? DISAGREES : "#333",
+          stroke: at.halo ? "white" : void 0,
+          "stroke-width": at.halo ? 3 : void 0,
+          "paint-order": "stroke",
+          "text-anchor": at.anchor
+        },
+        text
+      )
+    );
+  };
+  return el("g", {}, ...[reference, ...rows].map(rowTree));
+}
+
+export {
+  ON_REFERENCE,
+  OFF_REFERENCE,
+  OUTSIDE_CUT,
+  GENE_INK,
+  BAR_PX,
+  GAP_PX,
+  kb,
+  walkRowReadout,
+  readoutPlacement,
+  unitTicks,
+  runPaint,
+  alongRow,
+  rowSpan,
+  genesOnRow,
+  placeRowGenes,
+  boxesGenes,
+  rowGeneBoxes,
+  walkRowsKey,
+  DISAGREES,
+  walkRowsKeyTree,
+  coalesceRuns,
+  walkRowsTree
+};

package/dist/chunks/chunk-72N5DJHZ.js

@@ -0,0 +1,155 @@
+import {
+  stableCoordinate
+} from "./chunk-CDLPYR5O.js";
+import {
+  pathOrigin,
+  surveyPaths
+} from "./chunk-ST2IBUAN.js";
+
+// src/gfa/gfaConverter.ts
+function surveySegments(gfaGraph) {
+  const canonical = /* @__PURE__ */ new Map();
+  const traversals = /* @__PURE__ */ new Map();
+  function claim(id, strand) {
+    if (!canonical.has(id)) {
+      canonical.set(id, strand);
+    }
+  }
+  function traverse(id, strand) {
+    claim(id, strand);
+    traversals.set(id, (traversals.get(id) ?? 0) + 1);
+  }
+  for (const link of gfaGraph.links) {
+    claim(link.source, link.strand1 === "-" ? "-" : "+");
+    claim(link.target, link.strand2 === "-" ? "-" : "+");
+  }
+  for (const gfaPath of gfaGraph.paths) {
+    for (const segment of gfaPath.path.split(",")) {
+      traverse(segment.slice(0, -1), segment.endsWith("-") ? "-" : "+");
+    }
+  }
+  for (const walk of gfaGraph.walks) {
+    for (const seg of walk.segments) {
+      traverse(seg.id, seg.strand === "-" ? "-" : "+");
+    }
+  }
+  return { canonical, traversals };
+}
+var walkStart = (w) => w.start === -1 ? 0 : w.start;
+function anchorablePaths(gfaGraph) {
+  return [
+    ...gfaGraph.paths.map((p) => ({
+      ...pathOrigin(p.name),
+      steps: p.path.split(",").map((segment) => ({
+        id: segment.slice(0, -1),
+        strand: segment.endsWith("-") ? "-" : "+"
+      }))
+    })),
+    ...gfaGraph.walks.map((w) => ({
+      name: `${w.sample}#${w.haplotype}#${w.contig}`,
+      start: walkStart(w),
+      steps: w.segments.map((s) => ({
+        id: s.id,
+        strand: s.strand === "-" ? "-" : "+"
+      }))
+    }))
+  ];
+}
+function carriedSamples(gfaNode) {
+  const sm = gfaNode.tags.SM;
+  if (typeof sm !== "string") {
+    return void 0;
+  }
+  const samples = sm.split(",").map((s) => s.trim()).filter(Boolean);
+  return samples.length > 0 ? samples : void 0;
+}
+var positive = (v) => typeof v === "number" && v > 0 ? v : void 0;
+function statedDepth({ tags, length }) {
+  const count = positive(tags.RC) ?? positive(tags.FC) ?? positive(tags.KC);
+  return positive(tags.dp) ?? positive(tags.DP) ?? (count !== void 0 && length > 0 ? count / length : void 0);
+}
+function makeNode(gfaNode, strand, depth) {
+  return {
+    id: `${gfaNode.id}${strand}`,
+    name: gfaNode.id,
+    length: gfaNode.length,
+    depth,
+    stable: stableCoordinate(gfaNode),
+    samples: carriedSamples(gfaNode)
+  };
+}
+function convertGFAToGraph(gfaGraph, name = "Imported GFA") {
+  const nodes = [];
+  const edges = [];
+  const { canonical, traversals } = surveySegments(gfaGraph);
+  const nodeId = (segmentId) => `${segmentId}${canonical.get(segmentId) ?? "+"}`;
+  for (const gfaNode of gfaGraph.nodes) {
+    const depth = statedDepth(gfaNode) ?? Math.max(traversals.get(gfaNode.id) ?? 1, 1);
+    nodes.push(makeNode(gfaNode, canonical.get(gfaNode.id) ?? "+", depth));
+  }
+  for (const link of gfaGraph.links) {
+    edges.push({
+      from: nodeId(link.source),
+      to: nodeId(link.target),
+      fromStrand: link.strand1 === "-" ? "-" : "+",
+      toStrand: link.strand2 === "-" ? "-" : "+"
+    });
+  }
+  const paths = [];
+  const edgeToPathsMap = /* @__PURE__ */ new Map();
+  const edgeKey = (a, b) => [a, b].sort().join("--");
+  function recordPathEdges(nodeIds, name2) {
+    for (let i = 0; i < nodeIds.length - 1; i++) {
+      const key = edgeKey(nodeIds[i], nodeIds[i + 1]);
+      if (!edgeToPathsMap.has(key)) {
+        edgeToPathsMap.set(key, /* @__PURE__ */ new Set());
+      }
+      edgeToPathsMap.get(key).add(name2);
+    }
+  }
+  for (const gfaPath of gfaGraph.paths) {
+    const nodeIds = gfaPath.path.split(",").map((segment) => nodeId(segment.slice(0, -1)));
+    paths.push({
+      name: gfaPath.name,
+      nodeIds,
+      start: pathOrigin(gfaPath.name).start
+    });
+    recordPathEdges(nodeIds, gfaPath.name);
+  }
+  for (const walk of gfaGraph.walks) {
+    const nodeIds = walk.segments.map((seg) => nodeId(seg.id));
+    const name2 = `${walk.sample}#${walk.haplotype}#${walk.contig}`;
+    paths.push({
+      name: name2,
+      nodeIds,
+      start: walkStart(walk),
+      sample: walk.sample,
+      haplotype: walk.haplotype,
+      contig: walk.contig
+    });
+    recordPathEdges(nodeIds, name2);
+  }
+  for (const edge of edges) {
+    const pathIds = edgeToPathsMap.get(edgeKey(edge.from, edge.to));
+    if (pathIds && pathIds.size > 0) {
+      edge.pathIds = [...pathIds];
+    }
+  }
+  const lengths = new Map(gfaGraph.nodes.map((n) => [n.id, n.length]));
+  const anchoring = gfaGraph.paths.length > 0 || gfaGraph.walks.length > 0 ? surveyPaths(anchorablePaths(gfaGraph), (id) => lengths.get(id) ?? 0) : void 0;
+  return {
+    name,
+    nodes,
+    edges,
+    paths: paths.length > 0 ? paths : void 0,
+    anchorPaths: anchoring?.anchorPaths,
+    pathVisits: anchoring?.pathVisits,
+    // rGFA's own tags win wherever they are present; pathAnchoring only ever
+    // fills in for a graph that carries none.
+    anchoredBy: nodes.some((n) => n.stable) ? "tags" : void 0
+  };
+}
+
+export {
+  convertGFAToGraph
+};

package/dist/chunks/chunk-73RSLGZT.js

@@ -0,0 +1,73 @@
+import {
+  GBZ_CUT_DEFAULTS,
+  cutWindowGFA,
+  haplotypeWanted,
+  referencePathQuery,
+  referenceSamplesOf,
+  resolveReferenceSample
+} from "./chunk-LTUWJKHD.js";
+
+// src/gbzCut.ts
+import { GBZBase } from "@gmod/gbz-base";
+var HPRC_GBZ = {
+  db: "https://s3-us-west-2.amazonaws.com/human-pangenomics/pangenomes/freeze/release2/minigraph-cactus/v2.1/hprc-v2.1-mc-grch38/hprc-v2.1-mc-grch38.gbz.db",
+  index: "https://jbrowse.org/demos/hprc/hprc-v2.1-mc-grch38.haplotype-index.f3.db"
+};
+function haplotypeIndexBeside(db) {
+  const GBZ_DB = /\.gbz\.db$/i;
+  return GBZ_DB.test(db) ? db.replace(GBZ_DB, ".haplotype-index.db") : void 0;
+}
+function parseRegion(text) {
+  const m = /^\s*([^:\s]+):([\d,]+)-([\d,]+)\s*$/.exec(text);
+  if (!m) {
+    throw new Error(
+      `"${text}" is not a region like chr6:160,614,798-160,647,758`
+    );
+  }
+  const n = (s) => Number(s.replaceAll(",", ""));
+  return { refName: m[1], start: n(m[2]), end: n(m[3]) };
+}
+async function openGbz(db, index) {
+  const base = await GBZBase.open({ source: db, haplotypeIndex: index });
+  return { base, referenceSamples: await referenceSamplesOf(base) };
+}
+function referenceSample(ref, samples) {
+  try {
+    return resolveReferenceSample({
+      configured: "",
+      anchorPrefix: ref ?? samples[0] ?? "",
+      referenceSamples: samples
+    });
+  } catch (e) {
+    if (ref) {
+      return ref;
+    }
+    throw e;
+  }
+}
+async function cutGbzRegion({ base, referenceSamples }, src, signal) {
+  const region = parseRegion(src.region);
+  const sample = referenceSample(src.referenceSample, referenceSamples);
+  const query = await referencePathQuery(base, sample, region.refName);
+  if (!query) {
+    throw new Error(`${sample} has no indexed path named ${region.refName}`);
+  }
+  signal?.throwIfAborted();
+  const wanted = src.haplotypes?.length ? src.haplotypes : void 0;
+  const text = await cutWindowGFA(base, query, region.start, region.end, {
+    context: src.context ?? GBZ_CUT_DEFAULTS.context,
+    snarls: src.snarls ?? GBZ_CUT_DEFAULTS.snarls,
+    limit: GBZ_CUT_DEFAULTS.limit,
+    signal,
+    keep: wanted ? (name) => haplotypeWanted(name, wanted) : void 0
+  });
+  return { text, region, sample };
+}
+
+export {
+  HPRC_GBZ,
+  haplotypeIndexBeside,
+  parseRegion,
+  openGbz,
+  cutGbzRegion
+};

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

@@ -0,0 +1,13 @@
+// src/loadBandage.ts
+var cached;
+function loadBandage() {
+  cached ??= import("./bandage-layout-3AR6BCUD.js").then((mod) => mod.default()).catch((e) => {
+    cached = void 0;
+    throw e;
+  });
+  return cached;
+}
+
+export {
+  loadBandage
+};