@jbrowse/bandage-core 6.0.1 → 6.0.3

package/dist/chunks/chunk-HNQPEMYE.js

@@ -0,0 +1,297 @@
+import {
+  ROW_HEIGHT_PX
+} from "./chunk-CPMHA4W5.js";
+import {
+  isBackbone
+} from "./chunk-FYQWPEEY.js";
+
+// src/layout/orderedLayout.ts
+var GUTTER = 12;
+var LANE_PX = ROW_HEIGHT_PX;
+function nodeWidth(node) {
+  return 10 + 8 * Math.log2(1 + node.length);
+}
+function compare(a, b) {
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+function compareKeys(a, b) {
+  return compare(a.at, b.at) || compare(a.side, b.side) || compare(a.hops, b.hops);
+}
+var UNREACHED = { at: Infinity, side: 0, hops: 0 };
+function referenceOrder(graph) {
+  const byId = new Map(graph.nodes.map((n) => [n.id, n]));
+  const key = orderKeys(graph);
+  return graph.nodes.map((n) => n.id).sort(
+    (a, b) => compareKeys(key.get(a) ?? UNREACHED, key.get(b) ?? UNREACHED) || compare(byId.get(a).name, byId.get(b).name) || compare(a, b)
+  );
+}
+function placeByWalks(graph, backbone) {
+  const isNode = new Set(graph.nodes.map((n) => n.id));
+  const startOf = new Map(backbone.map((n) => [n.id, n.stable.start]));
+  const next = /* @__PURE__ */ new Map();
+  const prev = /* @__PURE__ */ new Map();
+  backbone.forEach((n, i) => {
+    prev.set(n.id, backbone[i - 1]?.id);
+    next.set(n.id, backbone[i + 1]?.id);
+  });
+  let head = backbone[0]?.id;
+  const insertAfter = (at, id) => {
+    const after = next.get(at);
+    next.set(at, id);
+    prev.set(id, at);
+    next.set(id, after);
+    if (after !== void 0) {
+      prev.set(after, id);
+    }
+  };
+  const insertBefore = (at, id) => {
+    const before = prev.get(at);
+    if (before === void 0) {
+      head = id;
+      prev.set(id, void 0);
+      next.set(id, at);
+      prev.set(at, id);
+    } else {
+      insertAfter(before, id);
+    }
+  };
+  for (const path of graph.paths ?? []) {
+    let rising = 0;
+    let falling = 0;
+    let last;
+    for (const id of path.nodeIds) {
+      const start = startOf.get(id);
+      if (start !== void 0) {
+        if (last !== void 0 && start !== last) {
+          if (start > last) {
+            rising++;
+          } else {
+            falling++;
+          }
+        }
+        last = start;
+      }
+    }
+    const ids = falling > rising ? [...path.nodeIds].reverse() : path.nodeIds;
+    let from;
+    const leading = /* @__PURE__ */ new Set();
+    for (const id of ids) {
+      if (next.has(id)) {
+        if (from === void 0) {
+          for (const lead of leading) {
+            insertBefore(id, lead);
+          }
+        }
+        from = id;
+      } else if (isNode.has(id)) {
+        if (from === void 0) {
+          leading.add(id);
+        } else {
+          insertAfter(from, id);
+          from = id;
+        }
+      }
+    }
+  }
+  const placed = [];
+  for (let id = head; id !== void 0; id = next.get(id)) {
+    placed.push(id);
+  }
+  return placed;
+}
+function placeBySearch(adjacent, key) {
+  const queue = [...key.entries()].sort(([a, ka], [b, kb]) => compareKeys(ka, kb) || compare(a, b)).map(([id]) => id);
+  const placed = queue.length;
+  for (const id of queue) {
+    const from = key.get(id);
+    for (const nb of adjacent.get(id) ?? []) {
+      if (!key.has(nb)) {
+        key.set(nb, { at: from.at, side: 1, hops: from.hops + 1 });
+        queue.push(nb);
+      }
+    }
+  }
+  const searched = new Set(queue.slice(placed));
+  const sided = /* @__PURE__ */ new Set();
+  for (const seed of searched) {
+    if (sided.has(seed)) {
+      continue;
+    }
+    const { at } = key.get(seed);
+    const run = [seed];
+    sided.add(seed);
+    let farHalf = true;
+    for (const id of run) {
+      const { hops } = key.get(id);
+      let deadEnd = true;
+      let touchesLeft = false;
+      for (const nb of adjacent.get(id) ?? []) {
+        const other = key.get(nb);
+        if (other.at === at && searched.has(nb)) {
+          deadEnd &&= other.hops <= hops;
+          if (!sided.has(nb)) {
+            sided.add(nb);
+            run.push(nb);
+          }
+        } else if (other.at !== at) {
+          touchesLeft ||= other.at < at;
+          farHalf &&= other.at < at;
+        }
+      }
+      farHalf &&= !deadEnd || touchesLeft;
+    }
+    if (farHalf) {
+      for (const id of run) {
+        const k = key.get(id);
+        key.set(id, { ...k, side: -1, hops: -k.hops });
+      }
+    }
+  }
+}
+function orderKeys(graph) {
+  const ids = new Set(graph.nodes.map((n) => n.id));
+  const adjacent = /* @__PURE__ */ new Map();
+  for (const e of graph.edges) {
+    if (!ids.has(e.from) || !ids.has(e.to)) {
+      continue;
+    }
+    ;
+    (adjacent.get(e.from) ?? adjacent.set(e.from, []).get(e.from)).push(e.to);
+    (adjacent.get(e.to) ?? adjacent.set(e.to, []).get(e.to)).push(e.from);
+  }
+  const backbone = graph.nodes.filter(isBackbone).sort(
+    (a, b) => compare(a.stable.start, b.stable.start) || compare(a.name, b.name)
+  );
+  const key = /* @__PURE__ */ new Map();
+  placeByWalks(graph, backbone).forEach((id, rank) => {
+    key.set(id, { at: rank, side: 0, hops: 0 });
+  });
+  placeBySearch(adjacent, key);
+  return key;
+}
+function layerGraph(graph) {
+  const byId = new Map(graph.nodes.map((n) => [n.id, n]));
+  const order = referenceOrder(graph);
+  const key = new Map(order.map((id, i) => [id, i]));
+  const isRef = (id) => isBackbone(byId.get(id));
+  const preds = new Map(order.map((id) => [id, []]));
+  const succs = new Map(order.map((id) => [id, []]));
+  const link = (a, b) => {
+    preds.get(b).push(a);
+    succs.get(a).push(b);
+  };
+  for (const e of graph.edges) {
+    if (e.from === e.to || !key.has(e.from) || !key.has(e.to)) {
+      continue;
+    }
+    if (key.get(e.from) < key.get(e.to)) {
+      link(e.from, e.to);
+    } else {
+      link(e.to, e.from);
+    }
+  }
+  const backbone = order.filter(isRef);
+  for (let i = 1; i < backbone.length; i++) {
+    link(backbone[i - 1], backbone[i]);
+  }
+  const layerOf = /* @__PURE__ */ new Map();
+  for (const id of order) {
+    let l = 0;
+    for (const p of preds.get(id)) {
+      l = Math.max(l, layerOf.get(p) + 1);
+    }
+    layerOf.set(id, l);
+  }
+  for (let i = order.length - 1; i >= 0; i--) {
+    const id = order[i];
+    const s = succs.get(id);
+    if (isRef(id) || s.length === 0) {
+      continue;
+    }
+    let minSucc = Infinity;
+    for (const t of s) {
+      minSucc = Math.min(minSucc, layerOf.get(t));
+    }
+    const lo = layerOf.get(id);
+    const hi = Math.max(lo, minSucc - 1);
+    layerOf.set(id, Math.floor((lo + hi) / 2));
+  }
+  const layers = [];
+  for (const id of order) {
+    ;
+    (layers[layerOf.get(id)] ??= []).push(id);
+  }
+  return { layers, layerOf, preds };
+}
+function orderedLayout(graph) {
+  if (!graph.nodes.some(isBackbone)) {
+    return void 0;
+  }
+  const byId = new Map(graph.nodes.map((n) => [n.id, n]));
+  const isRef = (id) => isBackbone(byId.get(id));
+  const { layers, layerOf: layer, preds } = layerGraph(graph);
+  const layerWidth = layers.map((ids) => {
+    let w = 0;
+    for (const id of ids) {
+      w = Math.max(w, nodeWidth(byId.get(id)));
+    }
+    return w;
+  });
+  const layerX = [];
+  let x = 0;
+  for (let l = 0; l < layers.length; l++) {
+    layerX[l] = x;
+    x += layerWidth[l] + GUTTER;
+  }
+  const y = /* @__PURE__ */ new Map();
+  for (const ids of layers) {
+    const free = [];
+    for (const id of ids) {
+      if (isRef(id)) {
+        y.set(id, 0);
+        continue;
+      }
+      const placed = preds.get(id).filter((p) => y.has(p));
+      let ideal = 0;
+      for (const p of placed) {
+        ideal += y.get(p) / placed.length;
+      }
+      free.push({ id, ideal: ideal === 0 ? LANE_PX : ideal });
+    }
+    free.sort((a, b) => a.ideal - b.ideal);
+    const taken = /* @__PURE__ */ new Set([0]);
+    for (const { id, ideal } of free) {
+      let lane = Math.round(ideal / LANE_PX);
+      if (lane === 0) {
+        lane = ideal >= 0 ? 1 : -1;
+      }
+      for (let d = 1; taken.has(lane); d++) {
+        if (!taken.has(lane + d)) {
+          lane += d;
+        } else if (!taken.has(lane - d)) {
+          lane -= d;
+        }
+      }
+      taken.add(lane);
+      y.set(id, lane * LANE_PX);
+    }
+  }
+  const nodePositions = {};
+  for (const n of graph.nodes) {
+    const l = layer.get(n.id);
+    const w = nodeWidth(n);
+    const cx = layerX[l] + layerWidth[l] / 2;
+    const ny = y.get(n.id);
+    nodePositions[n.id] = [
+      { x: cx - w / 2, y: ny },
+      { x: cx + w / 2, y: ny }
+    ];
+  }
+  return { nodePositions, referenceAxis: false, pixelRows: true };
+}
+
+export {
+  referenceOrder,
+  layerGraph,
+  orderedLayout
+};

package/dist/chunks/chunk-IGVV37VI.js

@@ -0,0 +1,60 @@
+import {
+  buildNeighbors
+} from "./chunk-ES2N6V56.js";
+import {
+  drawnNodeLength
+} from "./chunk-6JEWNXCQ.js";
+import {
+  isBackbone
+} from "./chunk-FYQWPEEY.js";
+
+// src/layout/referenceSeeds.ts
+var LANE_GAP = 30;
+function referenceSeeds(graph, scaling) {
+  const { opts } = scaling;
+  const drawn = new Map(
+    scaling.nodes.map((node) => [node.id, drawnNodeLength(opts, node.length)])
+  );
+  const drawnOf = (id) => drawn.get(id) ?? opts.minimumNodeLength;
+  const backbone = graph.nodes.filter(isBackbone).sort((a, b) => a.stable.start - b.stable.start);
+  const seeds = /* @__PURE__ */ new Map();
+  let x = 0;
+  for (const node of backbone) {
+    seeds.set(node.id, { x, y: 0 });
+    x += drawnOf(node.id) + opts.edgeLength;
+  }
+  const adjacent = buildNeighbors(graph);
+  const depth = new Map(backbone.map((node) => [node.id, 0]));
+  const queue = backbone.map((node) => node.id);
+  for (const id of queue) {
+    const at = seeds.get(id);
+    const next = depth.get(id) + 1;
+    for (const neighbour of adjacent.get(id) ?? []) {
+      if (depth.has(neighbour)) {
+        continue;
+      }
+      depth.set(neighbour, next);
+      seeds.set(neighbour, { x: at.x + drawnOf(id) / 2, y: LANE_GAP * next });
+      queue.push(neighbour);
+    }
+  }
+  let unreached = 0;
+  for (const node of graph.nodes) {
+    if (!seeds.has(node.id)) {
+      seeds.set(node.id, {
+        x: unreached++ * x / graph.nodes.length,
+        y: LANE_GAP * 3
+      });
+    }
+  }
+  return seeds;
+}
+function seededNodes(graph, scaling) {
+  const seeds = referenceSeeds(graph, scaling);
+  return scaling.nodes.map((node) => ({ ...node, ...seeds.get(node.id) }));
+}
+
+export {
+  referenceSeeds,
+  seededNodes
+};

package/dist/chunks/chunk-IO2PCPZI.js

@@ -0,0 +1,218 @@
+import {
+  orientToReference
+} from "./chunk-PUG7LXDF.js";
+import {
+  seededNodes
+} from "./chunk-IGVV37VI.js";
+import {
+  convertGFAToGraph
+} from "./chunk-72N5DJHZ.js";
+import {
+  parseGFA
+} from "./chunk-CDLPYR5O.js";
+import {
+  routeNodes,
+  takeRoutes,
+  withDeletionRoutes
+} from "./chunk-MI35EUIE.js";
+import {
+  anchorGraph
+} from "./chunk-ST2IBUAN.js";
+import {
+  mergeRuns,
+  splitRuns
+} from "./chunk-TAMCZHLW.js";
+import {
+  spreadFor
+} from "./chunk-UVBGRJQX.js";
+import {
+  drawnLengthOf,
+  drawnNodeLength,
+  layoutScaling
+} from "./chunk-6JEWNXCQ.js";
+import {
+  deletionEdges
+} from "./chunk-4EMPBO7S.js";
+import {
+  isBackbone
+} from "./chunk-FYQWPEEY.js";
+
+// src/pipeline.ts
+function loadGraph(text, name, opts = {}) {
+  const graph = anchorGraph(
+    convertGFAToGraph(parseGFA(text), name),
+    opts.referencePath
+  );
+  if (graph.nodes.length === 0) {
+    throw new Error(`No graph segments in ${name}`);
+  }
+  if (opts.maxNodes !== void 0 && graph.nodes.length > opts.maxNodes) {
+    throw new Error(
+      `Graph too large to draw: ${graph.nodes.length.toLocaleString()} nodes (limit ${opts.maxNodes.toLocaleString()}). Zoom in to a smaller region, or raise maxGraphNodes on this view.`
+    );
+  }
+  return graph;
+}
+var COMPONENT_SEPARATION = 15;
+function engineRequest(graph, scaling, settings) {
+  const anchored = graph.nodes.some(isBackbone);
+  const spaced = {
+    ...scaling,
+    opts: {
+      ...scaling.opts,
+      edgeLength: scaling.opts.edgeLength * (settings.spacing ?? 1)
+    }
+  };
+  return {
+    graph: {
+      nodes: anchored ? seededNodes(graph, spaced) : spaced.nodes,
+      edges: graph.edges
+    },
+    options: {
+      quality: settings.quality,
+      linearLayout: settings.linearLayout,
+      ...spaced.opts,
+      componentSeparation: COMPONENT_SEPARATION * (settings.componentSeparation ?? 1),
+      ...anchored ? { rotateComponents: false } : {}
+    }
+  };
+}
+function engineKey(graph, settings) {
+  const anchored = graph.nodes.some(isBackbone);
+  return `${settings.quality}|${settings.linearLayout}|${settings.bubbleSpread}|${settings.spacing ?? 1}|${settings.componentSeparation ?? 1}|${anchored}|${graph.referencePath ?? ""}`;
+}
+async function forceLayout(graph, settings, engine) {
+  const spread = spreadFor(settings.bubbleSpread);
+  const deletions = deletionEdges(graph);
+  const routed = withDeletionRoutes(graph, deletions);
+  const merged = mergeRuns(routed.graph, routed.ids);
+  const runs = {
+    ...merged.graph,
+    nodes: merged.graph.nodes.filter((n) => !routed.ids.has(n.id))
+  };
+  const engineScaling = layoutScaling(runs, spread);
+  const { result, duration } = await engine(
+    engineRequest(
+      merged.graph,
+      {
+        ...engineScaling,
+        nodes: [
+          ...engineScaling.nodes,
+          ...routeNodes(
+            graph,
+            deletions,
+            routed.routes,
+            drawnLengthOf(runs, spread),
+            engineScaling.opts
+          )
+        ]
+      },
+      settings
+    )
+  );
+  const scaling = layoutScaling(graph, spread);
+  const drawn = new Map(
+    scaling.nodes.map((n) => [n.id, drawnNodeLength(scaling.opts, n.length)])
+  );
+  const positions = splitRuns(
+    result.nodePositions,
+    merged.runs,
+    (id) => drawn.get(id) ?? 0
+  );
+  const { nodePositions, deletionRoutes } = takeRoutes(
+    graph.nodes.some(isBackbone) ? orientToReference(graph, positions) : positions,
+    routed.routes
+  );
+  return {
+    result: {
+      ...result,
+      nodePositions,
+      stranded: true,
+      ...deletions.length ? { deletionRoutes, extent: layoutExtent(deletionRoutes) } : {}
+    },
+    duration
+  };
+}
+function layoutExtent(nodePositions) {
+  let minX = Infinity;
+  let minY = Infinity;
+  let maxX = -Infinity;
+  let maxY = -Infinity;
+  for (const segments of Object.values(nodePositions)) {
+    for (const seg of segments) {
+      minX = Math.min(minX, seg.x);
+      minY = Math.min(minY, seg.y);
+      maxX = Math.max(maxX, seg.x);
+      maxY = Math.max(maxY, seg.y);
+    }
+  }
+  return { minX, minY, maxX, maxY };
+}
+var FIT_PADDING = 40;
+var MIN_ZOOM = 1e-6;
+var MAX_ZOOM = 100;
+function clampZoom(zoom) {
+  return Math.max(MIN_ZOOM, Math.min(MAX_ZOOM, zoom));
+}
+function fittedTranslateY(bounds, usableHeight, yScale, padTop = FIT_PADDING) {
+  const leftoverY = usableHeight - bounds.h * yScale;
+  return padTop - bounds.minY * yScale + Math.max(0, leftoverY) / 2;
+}
+function fitTransform(bounds, paneWidth, paneHeight, pixelRows, {
+  minScale = 0,
+  padLeft = FIT_PADDING,
+  padTop = FIT_PADDING,
+  padRight = FIT_PADDING,
+  padBottom = FIT_PADDING
+} = {}) {
+  const usableWidth = paneWidth - padLeft - padRight;
+  const usableHeight = paneHeight - padTop - padBottom;
+  if (usableWidth <= 0 || usableHeight <= 0 || !(bounds.w > 0 || !pixelRows && bounds.h > 0)) {
+    return void 0;
+  }
+  const fitX = bounds.w > 0 ? usableWidth / bounds.w : Infinity;
+  const fitY = bounds.h > 0 ? usableHeight / bounds.h : Infinity;
+  const scale = clampZoom(
+    Math.max(minScale, pixelRows ? fitX : Math.min(fitX, fitY))
+  );
+  const leftoverX = usableWidth - bounds.w * scale;
+  return {
+    scale,
+    translateX: padLeft - bounds.minX * scale + Math.max(0, leftoverX) / 2,
+    translateY: fittedTranslateY(
+      bounds,
+      usableHeight,
+      pixelRows ? 1 : scale,
+      padTop
+    )
+  };
+}
+function drawingBounds(layout, opts = {}) {
+  let { minX, minY, maxX, maxY } = layoutExtent(layout.nodePositions);
+  const { region } = opts;
+  if (layout.referenceAxis && region && region.end > region.start) {
+    minX = region.start;
+    maxX = region.end;
+  }
+  const extent = opts.extent ?? layout.extent;
+  if (extent) {
+    minX = Math.min(minX, extent.minX ?? minX);
+    minY = Math.min(minY, extent.minY ?? minY);
+    maxX = Math.max(maxX, extent.maxX ?? maxX);
+    maxY = Math.max(maxY, extent.maxY ?? maxY);
+  }
+  return { minX, minY, w: maxX - minX, h: maxY - minY };
+}
+
+export {
+  loadGraph,
+  engineRequest,
+  engineKey,
+  forceLayout,
+  layoutExtent,
+  FIT_PADDING,
+  clampZoom,
+  fittedTranslateY,
+  fitTransform,
+  drawingBounds
+};

package/dist/chunks/chunk-ISEI2FH3.js

@@ -0,0 +1,108 @@
+import {
+  bubbleSegmentIds,
+  classifyBubble,
+  formatBp
+} from "./chunk-WOO7QYKB.js";
+import {
+  svgPath
+} from "./chunk-2CVHXFK7.js";
+import {
+  isBackbone
+} from "./chunk-FYQWPEEY.js";
+
+// src/bubbles/bubbleHalos.ts
+var WHOLE_FRACTION = 0.9;
+var NAMED_WALKS = 2;
+var MIN_CHIPPED_BP = 1e3;
+function bubbleHalos(graph, bubbles, positions, walkLabel = (name) => name, repeats = []) {
+  const byName = new Map(graph.nodes.map((n) => [n.name, n]));
+  const halos = [];
+  for (const bubble of bubbles) {
+    const parts = [];
+    let minX = Infinity;
+    let maxX = -Infinity;
+    let minY = Infinity;
+    const nodeIds = [];
+    const ends = [];
+    for (const name of bubbleSegmentIds(bubble)) {
+      const node = byName.get(name);
+      const line = node && positions[node.id];
+      if (!node || !line?.length) {
+        continue;
+      }
+      if (isBackbone(node) && (node.stable.start < bubble.start || node.stable.start >= bubble.end)) {
+        ends.push(line[Math.floor(line.length / 2)]);
+        continue;
+      }
+      nodeIds.push(node.id);
+      parts.push(svgPath(line.length === 1 ? [line[0], line[0]] : line));
+      for (const p of line) {
+        minX = Math.min(minX, p.x);
+        maxX = Math.max(maxX, p.x);
+        minY = Math.min(minY, p.y);
+      }
+    }
+    if (nodeIds.length === 0) {
+      continue;
+    }
+    const labelAt = { x: (minX + maxX) / 2, y: minY };
+    const anchor = ends.length ? {
+      x: ends.reduce((s, p) => s + p.x, 0) / ends.length,
+      y: ends.reduce((s, p) => s + p.y, 0) / ends.length
+    } : labelAt;
+    const sharing = /* @__PURE__ */ new Map();
+    for (const route of bubble.routes ?? []) {
+      for (const id of new Set(route.steps)) {
+        sharing.set(id, (sharing.get(id) ?? 0) + 1);
+      }
+    }
+    const routes = [];
+    for (const route of bubble.routes ?? []) {
+      if (bubble.longestAlleleLength < MIN_CHIPPED_BP) {
+        break;
+      }
+      if (route.steps.length === 0) {
+        continue;
+      }
+      const rarest = Math.min(...route.steps.map((id) => sharing.get(id)));
+      let at;
+      let far = -1;
+      for (const id of route.steps) {
+        if (sharing.get(id) !== rarest) {
+          continue;
+        }
+        for (const p of positions[id] ?? []) {
+          const d = Math.hypot(p.x - anchor.x, p.y - anchor.y);
+          if (d > far) {
+            far = d;
+            at = p;
+          }
+        }
+      }
+      if (at) {
+        routes.push({ route, at, text: routeText(route, walkLabel) });
+      }
+    }
+    halos.push({
+      bubble,
+      ...classifyBubble(bubble, repeats),
+      path: parts.join(""),
+      labelAt,
+      members: nodeIds.length,
+      nodeIds,
+      whole: nodeIds.length >= WHOLE_FRACTION * graph.nodes.length,
+      routes
+    });
+  }
+  return halos;
+}
+function routeText(route, walkLabel) {
+  const names = [...new Set(route.walks.map(walkLabel))].sort();
+  const shown = names.slice(0, NAMED_WALKS).join(", ");
+  const more = names.length > NAMED_WALKS ? ` +${names.length - NAMED_WALKS}` : "";
+  return `${shown}${more} \xB7 ${formatBp(route.bp)}`;
+}
+
+export {
+  bubbleHalos
+};

package/dist/chunks/chunk-JKJWSY4V.js

@@ -0,0 +1,32 @@
+// src/colorSchemes.ts
+var COLOR_SCHEMES = [
+  // Mirrors `layoutModes`' 'auto': a value the model resolves rather than a
+  // colour of its own. It exists because 'uniform' was the default, so a
+  // launched graph opened flat grey and both tutorials spent a step saying "now
+  // pick a colour" — one figure literally drives that click. A graph with
+  // reference coordinates resolves to 'reference-position', which is the one
+  // ramp a linear track beside it can be painted with too; a graph with none
+  // keeps 'uniform', because there the ramp would be a hue nothing earned.
+  //
+  // Resolve through `effectiveColorScheme`; the dropdown reads the raw prop, so
+  // "Auto" stays selectable and visible as what it is.
+  { value: "auto", label: "Auto" },
+  { value: "uniform", label: "Uniform" },
+  { value: "random", label: "Random" },
+  { value: "rainbow", label: "Rainbow" },
+  { value: "depth", label: "Depth" },
+  { value: "node-length", label: "Node length" },
+  { value: "stable-rank", label: "Stable rank" },
+  { value: "reference-position", label: "Reference position" },
+  { value: "grey", label: "Grey" }
+];
+var COLOR_SCHEME_VALUES = COLOR_SCHEMES.map((s) => s.value);
+function resolveColorScheme(scheme, graph) {
+  return scheme !== "auto" ? scheme : graph?.anchoredBy ? "reference-position" : "uniform";
+}
+
+export {
+  COLOR_SCHEMES,
+  COLOR_SCHEME_VALUES,
+  resolveColorScheme
+};