@jbrowse/bandage-core 6.0.1 → 6.0.3

package/dist/chunks/chunk-TAMCZHLW.js

@@ -0,0 +1,190 @@
+import {
+  ownStrand,
+  strandSides
+} from "./chunk-2CVHXFK7.js";
+import {
+  isBackbone
+} from "./chunk-FYQWPEEY.js";
+
+// src/layout/mergeRuns.ts
+function flip(strand) {
+  return strand === "+" ? "-" : "+";
+}
+function mergeRuns(graph, alone = /* @__PURE__ */ new Set()) {
+  const sides = graph.edges.map(strandSides);
+  const at = /* @__PURE__ */ new Map();
+  const attach = (id, side, ei) => {
+    const key = `${id}|${side}`;
+    const list = at.get(key);
+    if (list) {
+      list.push(ei);
+    } else {
+      at.set(key, [ei]);
+    }
+  };
+  graph.edges.forEach((edge, ei) => {
+    attach(edge.from, sides[ei].from, ei);
+    attach(edge.to, sides[ei].to, ei);
+  });
+  const joinAfter = (a) => {
+    const out = at.get(`${a}|end`);
+    if (out?.length !== 1) {
+      return void 0;
+    }
+    const ei = out[0];
+    const edge = graph.edges[ei];
+    return edge.from === a && edge.to !== a && !alone.has(a) && !alone.has(edge.to) && sides[ei].from === "end" && sides[ei].to === "start" && at.get(`${edge.to}|start`)?.length === 1 ? ei : void 0;
+  };
+  const joined = /* @__PURE__ */ new Set();
+  const runOf = /* @__PURE__ */ new Map();
+  const runs = /* @__PURE__ */ new Map();
+  for (const node of graph.nodes) {
+    const into = at.get(`${node.id}|start`);
+    const pred = into?.length === 1 ? graph.edges[into[0]].from : void 0;
+    if (runOf.has(node.id) || pred !== void 0 && joinAfter(pred) === into[0]) {
+      continue;
+    }
+    const run = [node.id];
+    for (; ; ) {
+      const ei = joinAfter(run.at(-1));
+      const next = ei === void 0 ? void 0 : graph.edges[ei].to;
+      if (next === void 0 || runOf.has(next)) {
+        break;
+      }
+      joined.add(ei);
+      run.push(next);
+    }
+    for (const id of run) {
+      runOf.set(id, node.id);
+    }
+    if (run.length > 1) {
+      runs.set(node.id, run);
+    }
+  }
+  for (const node of graph.nodes) {
+    if (!runOf.has(node.id)) {
+      runOf.set(node.id, node.id);
+    }
+  }
+  const byId = new Map(graph.nodes.map((n) => [n.id, n]));
+  const nodes = [];
+  for (const node of graph.nodes) {
+    if (runOf.get(node.id) !== node.id) {
+      continue;
+    }
+    const run = runs.get(node.id);
+    if (!run) {
+      nodes.push(node);
+      continue;
+    }
+    const members = run.map((id) => byId.get(id));
+    const backbone = members.filter(isBackbone);
+    const first = backbone.length ? backbone.reduce((a, b) => a.stable.start <= b.stable.start ? a : b) : members[0];
+    nodes.push({
+      id: node.id,
+      name: node.name,
+      length: members.reduce((sum, n) => sum + n.length, 0),
+      depth: node.depth,
+      stable: first.stable
+    });
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const edges = [];
+  graph.edges.forEach((edge, ei) => {
+    const from = runOf.get(edge.from);
+    const to = runOf.get(edge.to);
+    const side = sides[ei];
+    const key = `${from}|${side.from}>${to}|${side.to}`;
+    if (joined.has(ei) || seen.has(key)) {
+      return;
+    }
+    seen.add(key);
+    edges.push({
+      from,
+      to,
+      ...side.from === "start" ? { fromStrand: flip(ownStrand(from)) } : {},
+      ...side.to === "end" ? { toStrand: flip(ownStrand(to)) } : {}
+    });
+  });
+  return {
+    graph: { ...graph, nodes, edges, paths: void 0, pathVisits: void 0 },
+    runs
+  };
+}
+function splitRuns(positions, runs, weightOf) {
+  const out = { ...positions };
+  for (const [id, members] of runs) {
+    const line = positions[id];
+    if (!line?.length) {
+      continue;
+    }
+    delete out[id];
+    const arc = arcPrefix(line);
+    const total = arc.at(-1);
+    const weights = members.map((m) => Math.max(weightOf(m), 0));
+    const weightSum = weights.reduce((a, b) => a + b, 0) || members.length;
+    let from = 0;
+    members.forEach((member, k) => {
+      const share = weightSum ? weights[k] / weightSum * total : total / members.length;
+      const to = k === members.length - 1 ? total : from + share;
+      out[member] = slice(line, arc, from, to);
+      from = to;
+    });
+  }
+  return out;
+}
+function polylineSlice(line, from, to) {
+  if (line.length === 0) {
+    return [];
+  }
+  const arc = arcPrefix(line);
+  const total = arc.at(-1);
+  return slice(line, arc, from * total, to * total);
+}
+function polylineMidpoint(line) {
+  const arc = arcPrefix(line);
+  return pointAt(line, arc, arc.at(-1) / 2);
+}
+function arcPrefix(line) {
+  const arc = [0];
+  for (let i = 1; i < line.length; i++) {
+    arc.push(
+      arc[i - 1] + Math.hypot(line[i].x - line[i - 1].x, line[i].y - line[i - 1].y)
+    );
+  }
+  return arc;
+}
+function pointAt(line, arc, s) {
+  if (s <= 0) {
+    return { ...line[0] };
+  }
+  let i = 1;
+  while (i < arc.length && arc[i] < s) {
+    i++;
+  }
+  if (i >= arc.length) {
+    return { ...line.at(-1) };
+  }
+  const span = arc[i] - arc[i - 1];
+  const t = span > 0 ? (s - arc[i - 1]) / span : 0;
+  const a = line[i - 1];
+  const b = line[i];
+  return { x: a.x + (b.x - a.x) * t, y: a.y + (b.y - a.y) * t };
+}
+function slice(line, arc, from, to) {
+  const points = [pointAt(line, arc, from)];
+  for (let i = 0; i < line.length; i++) {
+    if (arc[i] > from && arc[i] < to) {
+      points.push({ ...line[i] });
+    }
+  }
+  points.push(pointAt(line, arc, to));
+  return points;
+}
+
+export {
+  mergeRuns,
+  splitRuns,
+  polylineSlice,
+  polylineMidpoint
+};

package/dist/chunks/chunk-TDQLINVI.js

@@ -0,0 +1,16 @@
+// src/util/wheelZoom.ts
+var ZOOM_PER_NOTCH = 1.1;
+var NOTCH_PX = 100;
+var LINE_PX = 40;
+var PAGE_PX = 800;
+var PINCH_GAIN = 10;
+var MAX_NOTCHES_PER_EVENT = 2;
+function wheelZoomFactor(e) {
+  const px = e.deltaY * (e.deltaMode === 1 ? LINE_PX : e.deltaMode === 2 ? PAGE_PX : 1);
+  const notches = (e.ctrlKey ? PINCH_GAIN : 1) * px / NOTCH_PX;
+  return ZOOM_PER_NOTCH ** -Math.max(-MAX_NOTCHES_PER_EVENT, Math.min(MAX_NOTCHES_PER_EVENT, notches));
+}
+
+export {
+  wheelZoomFactor
+};

package/dist/chunks/chunk-TEDQJPMI.js

@@ -0,0 +1,131 @@
+import {
+  parseCs
+} from "./chunk-C44YRP5F.js";
+
+// src/tubeMap/reads.ts
+function canonicalStrand(node) {
+  return node.id.endsWith("-") ? "-" : "+";
+}
+function stepName(node, strand) {
+  return strand === canonicalStrand(node) ? node.id : `-${node.id}`;
+}
+function stepStarts(lengths, total) {
+  const starts = lengths.map(() => void 0);
+  let head = 0;
+  let i = 0;
+  for (; i < lengths.length && lengths[i] !== void 0; i++) {
+    starts[i] = head;
+    head += lengths[i];
+  }
+  let tail = total;
+  for (let j = lengths.length - 1; j > i && lengths[j] !== void 0; j--) {
+    tail -= lengths[j];
+    starts[j] = tail;
+  }
+  return starts;
+}
+function mismatchesByStep(record, lengths) {
+  const byStep = record.path.map(() => []);
+  if (record.cs === void 0) {
+    return byStep;
+  }
+  const starts = stepStarts(lengths, record.pathLength);
+  const stepAt = (pos2, atEnd = false) => {
+    for (let s = 0; s < starts.length; s++) {
+      const start = starts[s];
+      const length = lengths[s];
+      if (start !== void 0 && length !== void 0 && start <= pos2 && (pos2 < start + length || atEnd && pos2 === start + length)) {
+        return { s, local: pos2 - start, room: start + length - pos2 };
+      }
+    }
+    return void 0;
+  };
+  const add = (s, mismatch) => {
+    const list = byStep[s];
+    const last = list.at(-1);
+    if (mismatch.type === "substitution" && last?.type === "substitution" && last.pos + last.seq.length === mismatch.pos) {
+      last.seq += mismatch.seq;
+    } else {
+      list.push(mismatch);
+    }
+  };
+  let pos = record.pathStart;
+  for (const op of parseCs(record.cs)) {
+    if (op.op === "match") {
+      pos += op.length;
+    } else if (op.op === "substitution") {
+      const at = stepAt(pos);
+      if (at) {
+        add(at.s, { type: "substitution", pos: at.local, seq: op.seq });
+      }
+      pos += 1;
+    } else if (op.op === "insertion") {
+      const at = stepAt(pos, pos === record.pathEnd);
+      if (at) {
+        add(at.s, { type: "insertion", pos: at.local, seq: op.seq });
+      }
+    } else {
+      let left = op.length;
+      while (left > 0) {
+        const at = stepAt(pos);
+        const take = at ? Math.min(left, at.room) : left;
+        if (at) {
+          add(at.s, { type: "deletion", pos: at.local, length: take });
+        }
+        pos += take;
+        left -= take;
+      }
+    }
+  }
+  return byStep;
+}
+function tubeMapReads(graph, records, firstId) {
+  const nodeByName = new Map(graph.nodes.map((n) => [n.name, n]));
+  const reads = [];
+  for (const record of records) {
+    const nodes = record.path.map((step) => nodeByName.get(step.name));
+    const kept = nodes.flatMap((node, i) => node ? [i] : []);
+    const first = kept[0];
+    const last = kept.at(-1);
+    if (first !== void 0 && last !== void 0) {
+      const mismatches = mismatchesByStep(
+        record,
+        nodes.map((n) => n?.length)
+      );
+      const names = kept.map((i) => stepName(nodes[i], record.path[i].strand));
+      const lastLength = nodes[last].length;
+      reads.push({
+        id: firstId + reads.length,
+        name: record.name,
+        type: "read",
+        sourceTrackID: 1,
+        sequence: names,
+        sequenceNew: kept.map((i, k) => ({
+          nodeName: names[k],
+          mismatches: mismatches[i]
+        })),
+        firstNodeOffset: first === 0 ? record.pathStart : 0,
+        finalNodeCoverLength: last === record.path.length - 1 ? lastLength - (record.pathLength - record.pathEnd) : lastLength,
+        mapping_quality: record.mappingQuality === 255 ? 0 : record.mappingQuality,
+        is_secondary: record.secondary,
+        is_reverse: record.strand === "-"
+      });
+    }
+  }
+  return reads;
+}
+var FORWARD_READ_COLORS = ["#6baed6", "#4292c6", "#2171b5", "#08519c"];
+var REVERSE_READ_COLORS = ["#fb6a4a", "#ef3b2c", "#cb181d", "#a50f15"];
+function readColor(read) {
+  const colors = read.is_reverse ? REVERSE_READ_COLORS : FORWARD_READ_COLORS;
+  return colors[read.id % colors.length];
+}
+
+export {
+  canonicalStrand,
+  stepName,
+  tubeMapReads,
+  FORWARD_READ_COLORS,
+  REVERSE_READ_COLORS,
+  readColor
+};

package/dist/chunks/chunk-TZFWUT2C.js

@@ -0,0 +1,66 @@
+import {
+  projectAlleles
+} from "./chunk-RVS2QCOX.js";
+import {
+  buildNeighbors
+} from "./chunk-ES2N6V56.js";
+
+// src/layout/placeOffReference.ts
+var MIN_DELETION_BP = 1;
+var MIN_ALLELE_SPAN_FRACTION = 0.015;
+function placeOffReference({
+  graph,
+  span,
+  rowY,
+  positions
+}) {
+  const minSpan = span * MIN_ALLELE_SPAN_FRACTION;
+  const alleles = projectAlleles(graph);
+  const byId = new Map(graph.nodes.map((n) => [n.id, n]));
+  const alleleDeletions = [];
+  for (const allele of alleles) {
+    const skipped = allele.refSpan - allele.pathLength;
+    if (skipped >= MIN_DELETION_BP) {
+      alleleDeletions.push({ nodeIds: allele.nodeIds, bp: skipped });
+    }
+    const drawn = Math.max(allele.refSpan, minSpan);
+    const scale = allele.pathLength > 0 ? drawn / allele.pathLength : 0;
+    allele.nodeIds.forEach((nodeId, i) => {
+      const node = byId.get(nodeId);
+      if (node) {
+        const offset = allele.nodeOffsets[i];
+        const even = drawn / allele.nodeIds.length;
+        const at = (bp) => allele.start + bp * scale;
+        const y = rowY(node);
+        positions[nodeId] = scale ? [
+          { x: at(offset), y },
+          { x: at(offset + node.length), y }
+        ] : [
+          { x: allele.start + i * even, y },
+          { x: allele.start + (i + 1) * even, y }
+        ];
+      }
+    });
+  }
+  const neighbors = buildNeighbors(graph);
+  const queue = Object.keys(positions);
+  for (const fromId of queue) {
+    const fromEnd = positions[fromId].at(-1).x;
+    for (const nextId of neighbors.get(fromId) ?? []) {
+      const next = byId.get(nextId);
+      if (next && !(nextId in positions)) {
+        const y = rowY(next);
+        positions[nextId] = [
+          { x: fromEnd, y },
+          { x: fromEnd + minSpan, y }
+        ];
+        queue.push(nextId);
+      }
+    }
+  }
+  return alleleDeletions;
+}
+
+export {
+  placeOffReference
+};

package/dist/chunks/chunk-UVBGRJQX.js

@@ -0,0 +1,50 @@
+import {
+  MEAN_NODE_LENGTH,
+  PROPORTIONAL_LENGTH
+} from "./chunk-6JEWNXCQ.js";
+
+// src/bubbleSpreads.ts
+var BUBBLE_SPREADS = [
+  {
+    value: "auto",
+    label: "Proportional",
+    description: "Bandage's own scale: a node draws proportional to its length, so a 1 bp allele is a speck.",
+    law: PROPORTIONAL_LENGTH,
+    minNodeFactor: 0
+  },
+  {
+    value: "open",
+    label: "Open bubbles",
+    description: "Give every allele a drawn length, so a bubble reads as two arms rather than a knot.",
+    law: PROPORTIONAL_LENGTH,
+    minNodeFactor: 2.5
+  },
+  {
+    value: "wide",
+    label: "Wide bubbles",
+    description: "As open, spread further. Best on a window of a dozen bubbles.",
+    law: PROPORTIONAL_LENGTH,
+    minNodeFactor: 10
+  },
+  {
+    value: "compress",
+    label: "Compress lengths",
+    description: "Pull the longest and shortest nodes towards the graph\u2019s mean, so a cut spanning kb and bp fits one pane.",
+    law: { power: 0.5, effect: 0.5 },
+    minNodeFactor: 0
+  }
+];
+var BUBBLE_SPREAD_VALUES = BUBBLE_SPREADS.map((s) => s.value);
+function spreadFor(spread) {
+  const entry = BUBBLE_SPREADS.find((s) => s.value === spread);
+  return {
+    law: entry?.law ?? PROPORTIONAL_LENGTH,
+    minNodeLength: (entry?.minNodeFactor ?? 0) * MEAN_NODE_LENGTH
+  };
+}
+
+export {
+  BUBBLE_SPREADS,
+  BUBBLE_SPREAD_VALUES,
+  spreadFor
+};

package/dist/chunks/chunk-VHW7FDHU.js

@@ -0,0 +1,42 @@
+import {
+  trimOrigins
+} from "./chunk-ST2IBUAN.js";
+
+// src/bubbles/popBubble.ts
+function bubbleSubgraph(graph, segmentIds) {
+  const keep = new Set(segmentIds);
+  const nodes = graph.nodes.filter((n) => keep.has(n.name));
+  const ids = new Set(nodes.map((n) => n.id));
+  const lengthOf = new Map(graph.nodes.map((n) => [n.id, n.length]));
+  const kept = /* @__PURE__ */ new Map();
+  const paths = graph.paths?.flatMap((p) => {
+    const first = p.nodeIds.findIndex((id) => ids.has(id));
+    if (first < 0) {
+      return [];
+    }
+    const nodeIds = p.nodeIds.filter((id) => ids.has(id));
+    kept.set(p.name, { first, nodeIds });
+    const before = p.nodeIds.slice(0, first).reduce((sum, id) => sum + (lengthOf.get(id) ?? 0), 0);
+    return [
+      {
+        ...p,
+        nodeIds,
+        ...p.start === void 0 ? {} : { start: p.start + before }
+      }
+    ];
+  });
+  return {
+    name: graph.name,
+    nodes,
+    edges: graph.edges.filter((e) => ids.has(e.from) && ids.has(e.to)),
+    ...paths?.length ? { paths } : {},
+    anchorPaths: trimOrigins(graph, kept),
+    pathVisits: graph.pathVisits,
+    anchoredBy: graph.anchoredBy,
+    referencePath: graph.referencePath
+  };
+}
+
+export {
+  bubbleSubgraph
+};

package/dist/chunks/chunk-VZQ4FKLR.js

@@ -0,0 +1,38 @@
+import {
+  referenceKnots,
+  warpX
+} from "./chunk-KQFOCDFY.js";
+
+// src/tubeMap/frame.ts
+var MIN_TUBE_Y_SCALE = 0.05;
+var NODE_BOX_PAD = 9;
+function squeeze(drawing, usableHeight) {
+  const { minY, maxY } = drawing.layout.bounds;
+  const h = maxY - minY;
+  return drawing.columns && h > 0 ? Math.max(MIN_TUBE_Y_SCALE, Math.min(1, usableHeight / h)) : 1;
+}
+function tubeMapFrame(drawing, view) {
+  const { scaleX, translateX, translateY } = view;
+  const yScale = view.scaleY * squeeze(drawing, view.usableHeight);
+  const y = (ty) => (ty - drawing.yOffset) * yScale + translateY;
+  const { columns } = drawing;
+  if (columns) {
+    const knots = referenceKnots(columns, (bp) => bp * scaleX + translateX);
+    return { x: (tx) => warpX(knots, tx), y, yScale };
+  }
+  return { x: (tx) => tx * scaleX + translateX, y, yScale };
+}
+function tubeMapNodeAt(drawing, { x, y }, sx, sy) {
+  let hit = null;
+  drawing.layout.nodes.forEach((node) => {
+    if (node.order >= 0 && x(node.x - NODE_BOX_PAD) <= sx && sx <= x(node.x + node.pixelWidth + NODE_BOX_PAD) && y(node.y - NODE_BOX_PAD) <= sy && sy <= y(node.y + node.contentHeight + NODE_BOX_PAD)) {
+      hit = node.name;
+    }
+  });
+  return hit;
+}
+
+export {
+  tubeMapFrame,
+  tubeMapNodeAt
+};

package/dist/chunks/chunk-WFX3MAKA.js

@@ -0,0 +1,102 @@
+import {
+  REFERENCE_RAMP_ALT_COLOR,
+  REFERENCE_RAMP_MAX_HUE,
+  hslToRgb
+} from "./chunk-PCZ4PTYC.js";
+
+// src/walkEncoding.ts
+import { packAbgr } from "@jbrowse/core/util/colorBits";
+var WALK_FIELDS = [
+  { value: "progress", label: "Progress along the walk" },
+  { value: "walk", label: "One colour for the walk" },
+  { value: "reference", label: "Reference position" }
+];
+var WALK_SCHEMES = [
+  { value: "grey", label: "Grey to black", ends: ["#a3a3a3", "#151515"] },
+  { value: "blue", label: "Cyan to navy", ends: ["#6ee0f0", "#0b2c7a"] },
+  { value: "red", label: "Yellow to red", ends: ["#ffd24a", "#b3121b"] },
+  { value: "purple", label: "Pink to plum", ends: ["#f5a3d8", "#5e1a6e"] },
+  { value: "green", label: "Lime to forest", ends: ["#b6e36c", "#0b5d3b"] },
+  { value: "rainbow", label: "Rainbow" }
+];
+var FAMILIES = ["blue", "red", "purple", "green"];
+var isField = (v) => WALK_FIELDS.some((f) => f.value === v);
+var isScheme = (v) => WALK_SCHEMES.some((s) => s.value === v);
+function resolveEncoding(layer, reference, picked, alone = true) {
+  const { field: askedField, scheme: askedScheme } = layer.color ?? {};
+  const field = isField(askedField) ? askedField : alone ? "progress" : "walk";
+  const family = reference ? "grey" : FAMILIES[picked % FAMILIES.length];
+  const scheme = isScheme(askedScheme) ? askedScheme === "rainbow" && field !== "reference" ? family : askedScheme : family;
+  return { field, scheme };
+}
+var BASE_T = 0.5;
+var toLinear = (c) => c <= 0.04045 ? c / 12.92 : ((c + 0.055) / 1.055) ** 2.4;
+var toGamma = (c) => c <= 31308e-7 ? c * 12.92 : 1.055 * c ** (1 / 2.4) - 0.055;
+function oklab(hex) {
+  const [r, g, b] = [1, 3, 5].map(
+    (i) => toLinear(Number.parseInt(hex.slice(i, i + 2), 16) / 255)
+  );
+  const l = Math.cbrt(0.4122214708 * r + 0.5363325363 * g + 0.0514459929 * b);
+  const m = Math.cbrt(0.2119034982 * r + 0.6806995451 * g + 0.1073969566 * b);
+  const s = Math.cbrt(0.0883024619 * r + 0.2817188376 * g + 0.6299787005 * b);
+  return [
+    0.2104542553 * l + 0.793617785 * m - 0.0040720468 * s,
+    1.9779984951 * l - 2.428592205 * m + 0.4505937099 * s,
+    0.0259040371 * l + 0.7827717662 * m - 0.808675766 * s
+  ];
+}
+function oklabToRgb([L, a, b]) {
+  const l = (L + 0.3963377774 * a + 0.2158037573 * b) ** 3;
+  const m = (L - 0.1055613458 * a - 0.0638541728 * b) ** 3;
+  const s = (L - 0.0894841775 * a - 1.291485548 * b) ** 3;
+  return [
+    4.0767416621 * l - 3.3077115913 * m + 0.2309699292 * s,
+    -1.2684380046 * l + 2.6097574011 * m - 0.3413193965 * s,
+    -0.0041960863 * l - 0.7034186147 * m + 1.707614701 * s
+  ].map((c) => toGamma(Math.max(0, Math.min(1, c))) * 255);
+}
+function schemeRgb(scheme, t) {
+  const x = Math.max(0, Math.min(1, t));
+  const family = WALK_SCHEMES.find((s) => s.value === scheme);
+  if (!family || !("ends" in family)) {
+    return hslToRgb(x * REFERENCE_RAMP_MAX_HUE, 0.7, 0.5).map((c) => c * 255);
+  }
+  const from = oklab(family.ends[0]);
+  const to = oklab(family.ends[1]);
+  return oklabToRgb(from.map((v, i) => v + (to[i] - v) * x));
+}
+function schemeCss(scheme, t) {
+  const [r, g, b] = schemeRgb(scheme, t).map(Math.round);
+  return `rgb(${r}, ${g}, ${b})`;
+}
+function schemeColor(scheme, t) {
+  const [r, g, b] = schemeRgb(scheme, t).map(Math.round);
+  return packAbgr(r, g, b, 255);
+}
+function encodedColor({ field, scheme }, t) {
+  return field === "walk" ? schemeColor(scheme, BASE_T) : t === void 0 ? NO_VALUE_COLOR : schemeColor(scheme, t);
+}
+var NO_VALUE_COLOR = REFERENCE_RAMP_ALT_COLOR;
+function encodingStops({ field, scheme }) {
+  return field === "walk" ? [{ offset: 0, color: schemeCss(scheme, BASE_T) }] : Array.from({ length: 7 }, (_, i) => ({
+    offset: i / 6,
+    color: schemeCss(scheme, i / 6)
+  }));
+}
+function encodingSwatchCss(encoding) {
+  const stops = encodingStops(encoding);
+  return stops.length === 1 ? stops[0].color : `linear-gradient(to right, ${stops.map((s) => `${s.color} ${s.offset * 100}%`).join(", ")})`;
+}
+
+export {
+  WALK_FIELDS,
+  WALK_SCHEMES,
+  resolveEncoding,
+  schemeRgb,
+  schemeCss,
+  schemeColor,
+  encodedColor,
+  NO_VALUE_COLOR,
+  encodingStops,
+  encodingSwatchCss
+};