@jbrowse/bandage-core 6.0.1 → 6.0.2

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

@@ -0,0 +1,170 @@
+import {
+  encodedColor,
+  resolveEncoding
+} from "./chunk-IMW3AK27.js";
+import {
+  pathOrigin
+} from "./chunk-ST2IBUAN.js";
+import {
+  panSNContig
+} from "./chunk-BPLIXMH7.js";
+
+// src/walkHighlight.ts
+var isReference = (graph, name) => !!graph.referencePath && pathOrigin(name).name === graph.referencePath;
+function piecesOf(graph, name) {
+  return (graph.paths ?? []).filter((p) => p.name === name).sort((a, b) => (a.start ?? 0) - (b.start ?? 0));
+}
+function walkHighlight(graph, name) {
+  const pieces = piecesOf(graph, name);
+  const first = pieces[0];
+  if (!first) {
+    return void 0;
+  }
+  const byId = new Map(graph.nodes.map((n) => [n.id, n]));
+  const edgeAt = /* @__PURE__ */ new Map();
+  graph.edges.forEach((e, i) => {
+    edgeAt.set(`${e.from}>${e.to}`, i);
+  });
+  const lengthOf = (id) => byId.get(id)?.length ?? 0;
+  const bpOf = (path) => path.nodeIds.reduce((sum, id) => sum + lengthOf(id), 0);
+  const bp = pieces.reduce((sum, piece) => sum + bpOf(piece), 0);
+  const range = first.start === void 0 ? void 0 : {
+    contig: first.contig ?? panSNContig(pathOrigin(name).name),
+    start: first.start,
+    end: Math.max(...pieces.map((p) => (p.start ?? 0) + bpOf(p)))
+  };
+  const span = range ? range.end - range.start : bp;
+  const nodeIds = /* @__PURE__ */ new Set();
+  const edgeIndexes = /* @__PURE__ */ new Set();
+  const progress = /* @__PURE__ */ new Map();
+  let before = 0;
+  for (const piece of pieces) {
+    if (range) {
+      before = Math.max(before, (piece.start ?? 0) - range.start);
+    }
+    piece.nodeIds.forEach((id, i) => {
+      nodeIds.add(id);
+      if (i > 0) {
+        const a = piece.nodeIds[i - 1];
+        const index = edgeAt.get(`${a}>${id}`) ?? edgeAt.get(`${id}>${a}`);
+        if (index !== void 0) {
+          edgeIndexes.add(index);
+        }
+      }
+      const length = lengthOf(id);
+      if (!progress.has(id)) {
+        progress.set(id, span > 0 ? (before + length / 2) / span : 0);
+      }
+      before += length;
+    });
+  }
+  const reference = isReference(graph, name);
+  const referencePieces = reference ? [] : (graph.paths ?? []).filter((p) => isReference(graph, p.name));
+  return {
+    name,
+    reference,
+    range,
+    nodeIds,
+    edgeIndexes,
+    progress,
+    steps: pieces.reduce((sum, piece) => sum + piece.nodeIds.length, 0),
+    bp,
+    referenceBp: referencePieces.length > 0 ? referencePieces.reduce((sum, piece) => sum + bpOf(piece), 0) : void 0
+  };
+}
+function laneColors(graph, walk, encoding, ramp) {
+  const byId = new Map(graph.nodes.map((n) => [n.id, n]));
+  const colors = /* @__PURE__ */ new Map();
+  for (const [id, progress] of walk.progress) {
+    const node = byId.get(id);
+    const mid = ramp?.midpoints.get(id);
+    const t = encoding.field === "progress" ? progress : ramp && mid !== void 0 && !(node?.stable && node.stable.rank > 0) ? (mid - ramp.start) / ramp.span : void 0;
+    colors.set(id, encodedColor(encoding, t));
+  }
+  return colors;
+}
+function reversedNodes(graph, walk) {
+  const reversed = /* @__PURE__ */ new Set();
+  let bp = 0;
+  const referencePath = graph.referencePath;
+  if (!referencePath || walk.reference) {
+    return { reversed, bp };
+  }
+  const walkPath = pathOrigin(walk.name).name;
+  const byId = new Map(graph.nodes.map((n) => [n.id, n]));
+  for (const id of walk.progress.keys()) {
+    const node = byId.get(id);
+    const visits = node ? graph.pathVisits?.get(node.name) : void 0;
+    const own = visits?.find((v) => v.path === walkPath)?.strand;
+    const theirs = visits?.find((v) => v.path === referencePath)?.strand;
+    if (own && theirs && own !== theirs) {
+      reversed.add(id);
+      bp += node.length;
+    }
+  }
+  return { reversed, bp };
+}
+function walkLift(graph, layers, ramp) {
+  const seen = /* @__PURE__ */ new Set();
+  const lifted = layers.filter((layer) => !seen.has(layer.walk) && seen.add(layer.walk)).flatMap((layer) => {
+    const walk = walkHighlight(graph, layer.walk);
+    return walk ? [{ walk, layer }] : [];
+  }).sort((a, b) => Number(b.walk.reference) - Number(a.walk.reference));
+  if (lifted.length === 0) {
+    return void 0;
+  }
+  let picked = 0;
+  const walks = lifted.map(({ walk, layer }) => {
+    const encoding = resolveEncoding(
+      layer,
+      walk.reference,
+      walk.reference ? 0 : picked++,
+      lifted.length === 1
+    );
+    const { reversed, bp } = reversedNodes(graph, walk);
+    return {
+      ...walk,
+      encoding,
+      colors: laneColors(graph, walk, encoding, ramp),
+      reversed,
+      reversedBp: bp
+    };
+  });
+  return liftOf(walks, ramp);
+}
+var FACET_COLOR = { field: "progress", scheme: "red" };
+function facetLifts(graph, lift, layers, ramp) {
+  return lift.walks.map((walk) => {
+    const stated = layers.find((l) => l.walk === walk.name)?.color;
+    const encoding = resolveEncoding(
+      { walk: walk.name, color: { ...FACET_COLOR, ...stated } },
+      walk.reference,
+      0
+    );
+    return liftOf(
+      [
+        {
+          ...walk,
+          encoding,
+          colors: laneColors(graph, walk, encoding, ramp)
+        }
+      ],
+      ramp
+    );
+  });
+}
+function liftOf(walks, ramp) {
+  return {
+    walks,
+    referenceDomain: ramp ? { start: ramp.start, end: ramp.start + ramp.span } : void 0,
+    nodeIds: new Set(walks.flatMap((w) => [...w.nodeIds])),
+    edgeIndexes: new Set(walks.flatMap((w) => [...w.edgeIndexes])),
+    names: new Set(walks.map((w) => w.name))
+  };
+}
+
+export {
+  walkHighlight,
+  walkLift,
+  facetLifts
+};

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

@@ -0,0 +1,97 @@
+// src/facetGrid.ts
+var FACET_GAP_PX = 8;
+var FACET_TITLE_PX = 34;
+var FACET_PAD_PX = 12;
+var MIN_FACET_PANEL_PX = 60;
+function facetGrid({
+  count,
+  bounds,
+  pixelRows,
+  width,
+  room,
+  columns
+}) {
+  function tile(across) {
+    const rows = Math.ceil(count / across);
+    const panelWidth = Math.floor(
+      (width - (across - 1) * FACET_GAP_PX) / across
+    );
+    const panelRoom = (room - rows * FACET_TITLE_PX - (rows - 1) * FACET_GAP_PX) / rows;
+    const fitX = (panelWidth - 2 * FACET_PAD_PX) / bounds.w;
+    const fitY = bounds.h > 0 ? (panelRoom - 2 * FACET_PAD_PX) / bounds.h : Infinity;
+    const scale = pixelRows ? fitX : Math.min(fitX, fitY);
+    const drawn = pixelRows ? bounds.h : bounds.h * scale;
+    const height = Math.floor(
+      Math.max(
+        MIN_FACET_PANEL_PX,
+        Math.min(drawn + 2 * FACET_PAD_PX, panelRoom)
+      )
+    );
+    return {
+      columns: across,
+      width: panelWidth,
+      height,
+      scale,
+      total: rows * (height + FACET_TITLE_PX) + (rows - 1) * FACET_GAP_PX
+    };
+  }
+  if (columns !== void 0) {
+    return tile(Math.max(1, Math.min(count, Math.round(columns))));
+  }
+  let best = tile(1);
+  for (let across = 2; across <= count; across++) {
+    const grid = tile(across);
+    if (grid.scale > best.scale) {
+      best = grid;
+    }
+  }
+  return best;
+}
+function facetSettingOf(facet) {
+  const raw = typeof facet === "string" ? { field: facet } : facet ?? {};
+  const field = raw.field === "walk" || raw.field === "sample" ? raw.field : "";
+  return {
+    field,
+    domain: [...raw.domain ?? []],
+    ...raw.columns === void 0 ? {} : { columns: raw.columns }
+  };
+}
+function domainFirst(names, domain) {
+  const rank = new Map(domain.map((name, i) => [name, i]));
+  const listed = (name) => rank.get(name) ?? domain.length;
+  return names.map((name, i) => ({ name, i })).sort((a, b) => listed(a.name) - listed(b.name) || a.i - b.i).map(({ name }) => name);
+}
+function facetCells(names, by, domain = []) {
+  const wrapOrder = domainFirst(names, domain);
+  const wrap = {
+    columns: void 0,
+    count: names.length,
+    cells: names.map((name) => wrapOrder.indexOf(name))
+  };
+  if (by === "walk") {
+    return wrap;
+  }
+  const places = names.map((name) => {
+    const [sample, haplotype, contig] = name.split("#");
+    const n = Number(haplotype);
+    return contig !== void 0 && Number.isInteger(n) && n >= 0 ? { sample, column: Math.max(0, n - 1) } : void 0;
+  });
+  const rows = domainFirst(
+    [...new Set(places.flatMap((p) => p ? [p.sample] : []))],
+    domain
+  );
+  const columns = Math.max(1, ...places.map((p) => p ? p.column + 1 : 1));
+  const cells = places.map(
+    (p) => p ? rows.indexOf(p.sample) * columns + p.column : -1
+  );
+  return cells.includes(-1) || new Set(cells).size < cells.length ? wrap : { columns, count: rows.length * columns, cells };
+}
+
+export {
+  FACET_GAP_PX,
+  FACET_TITLE_PX,
+  FACET_PAD_PX,
+  facetGrid,
+  facetSettingOf,
+  facetCells
+};

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

@@ -0,0 +1,61 @@
+import {
+  bypassedPoints
+} from "./chunk-X32PABB7.js";
+import {
+  computeEdgeCurves,
+  edgeJoinOf,
+  routedEdgeCurves,
+  strandSides
+} from "./chunk-3PLYZLYV.js";
+
+// src/util/edgeCurves.ts
+var cache = /* @__PURE__ */ new WeakMap();
+function baseEdgeCurves(nodePositions, graph, axis, deletions, version, routes, stranded = false) {
+  const { scaleX, scaleY } = axis;
+  const cached = cache.get(nodePositions);
+  if (cached?.graph === graph && cached.scaleX === scaleX && cached.scaleY === scaleY && cached.deletions === deletions && cached.routes === routes && cached.stranded === stranded && cached.version === version) {
+    return cached.curves;
+  }
+  const curves = /* @__PURE__ */ new Map();
+  for (let ei = 0; ei < graph.edges.length; ei++) {
+    const edge = graph.edges[ei];
+    const from = nodePositions[edge.from];
+    const to = nodePositions[edge.to];
+    if (from?.length && to?.length) {
+      const bypassed = deletions?.get(ei);
+      const route = bypassed && routes?.[ei];
+      curves.set(
+        ei,
+        route ? routedEdgeCurves(
+          from,
+          to,
+          route,
+          stranded ? strandSides(edge) : void 0
+        ) : computeEdgeCurves(
+          from,
+          to,
+          edgeJoinOf(edge, stranded),
+          0,
+          0,
+          axis,
+          bypassed ? bypassedPoints(nodePositions, bypassed) : []
+        )
+      );
+    }
+  }
+  cache.set(nodePositions, {
+    graph,
+    scaleX,
+    scaleY,
+    deletions,
+    routes,
+    stranded,
+    version,
+    curves
+  });
+  return curves;
+}
+
+export {
+  baseEdgeCurves
+};

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-7CHJKABZ.js

@@ -0,0 +1,82 @@
+import {
+  pathOrigin
+} from "./chunk-ST2IBUAN.js";
+import {
+  groupDigits
+} from "./chunk-HCANBJDD.js";
+import {
+  isGenericSample
+} from "./chunk-BPLIXMH7.js";
+
+// src/pathColors.ts
+function nameHue(name) {
+  let hash = 0;
+  for (let i = 0; i < name.length; i++) {
+    hash = name.charCodeAt(i) + ((hash << 5) - hash);
+  }
+  return Math.abs(hash % 360);
+}
+function pathHueAt(index, count) {
+  return index * 360 / count;
+}
+var PATH_SATURATION = 0.7;
+var PATH_LIGHTNESS = 0.5;
+var MAX_PATH_COLORS = 16;
+function pathColorsLegible(pathCount) {
+  return pathCount > 0 && pathCount <= MAX_PATH_COLORS;
+}
+function pathCssColor(index, count) {
+  return `hsl(${pathHueAt(index, count)}, ${PATH_SATURATION * 100}%, ${PATH_LIGHTNESS * 100}%)`;
+}
+function pathGreyCssColor(index, count) {
+  const lightness = count > 1 ? 25 + 45 * index / (count - 1) : 45;
+  return `hsl(0, 0%, ${lightness}%)`;
+}
+function labelTiers(name) {
+  const parts = pathOrigin(name).name.split("#");
+  const full = parts.join("#");
+  if (parts.length >= 3 && isGenericSample(parts[0])) {
+    const contig = parts.slice(2).join("#");
+    return [contig, contig, full];
+  }
+  return [parts[0], parts.slice(0, 2).join("#"), full];
+}
+function offsetTiers(name, tiers) {
+  const { start } = pathOrigin(name);
+  return tiers.map((t) => `${t} @${groupDigits(start)}`);
+}
+function pathLegend(paths, colors) {
+  const firstOf = /* @__PURE__ */ new Map();
+  paths.forEach((path, i) => {
+    if (!firstOf.has(path.name)) {
+      firstOf.set(path.name, i);
+    }
+  });
+  const entries = [...firstOf].map(([name, i]) => ({ name, i }));
+  const named = entries.map((e) => labelTiers(e.name));
+  const candidates = [0, 1, 2].flatMap((t) => [
+    entries.map((_, k) => named[k][t]),
+    entries.map((e, k) => offsetTiers(e.name, named[k])[t])
+  ]);
+  const distinct = candidates.find(
+    (labels2) => new Set(labels2).size === entries.length
+  );
+  const labels = distinct ?? candidates.at(-1);
+  return entries.map(({ name, i }, k) => ({
+    name,
+    label: labels[k],
+    color: colors?.[i] ?? pathCssColor(i, paths.length)
+  }));
+}
+
+export {
+  nameHue,
+  pathHueAt,
+  PATH_SATURATION,
+  PATH_LIGHTNESS,
+  MAX_PATH_COLORS,
+  pathColorsLegible,
+  pathCssColor,
+  pathGreyCssColor,
+  pathLegend
+};

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
+};