@jbrowse/bandage-core 6.0.1 → 6.0.2

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

@@ -0,0 +1,102 @@
+import {
+  REFERENCE_RAMP_ALT_COLOR,
+  REFERENCE_RAMP_MAX_HUE,
+  hslToRgb
+} from "./chunk-3WHKR5TY.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
+};

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

package/dist/chunks/chunk-KCW7L3NV.js

@@ -0,0 +1,6 @@
+// src/version.ts
+var version = "6.0.2";
+
+export {
+  version
+};

package/dist/chunks/chunk-KQFOCDFY.js

@@ -0,0 +1,73 @@
+// src/tubeMap/warp.ts
+var MAX_GAP_PX = 24;
+var isReal = (c) => c.bp1 > c.bp0;
+function referenceKnots(columns, bpToScreen) {
+  const real = columns.filter(isReal);
+  if (real.length === 0) {
+    const first = columns[0];
+    return first ? [{ tx: first.x0, sx: bpToScreen(first.bp0) }] : [];
+  }
+  const screen = real.map((c) => ({
+    c,
+    s0: bpToScreen(c.bp0),
+    s1: bpToScreen(c.bp1),
+    trimLeft: 0,
+    trimRight: 0
+  }));
+  for (let i = 0; i + 1 < screen.length; i++) {
+    const left = screen[i];
+    const right = screen[i + 1];
+    const demand = Math.min(right.c.x0 - left.c.x1, MAX_GAP_PX);
+    const short = demand - (right.s0 - left.s1);
+    if (short > 0) {
+      const capLeft = (left.s1 - left.s0) / 2;
+      const capRight = (right.s1 - right.s0) / 2;
+      let fromLeft = Math.min(short / 2, capLeft);
+      const fromRight = Math.min(short - fromLeft, capRight);
+      fromLeft = Math.min(short - fromRight, capLeft);
+      left.trimRight = fromLeft;
+      right.trimLeft = fromRight;
+    }
+  }
+  const knots = [];
+  for (const { c, s0, s1, trimLeft, trimRight } of screen) {
+    knots.push(
+      { tx: c.x0, sx: s0 + trimLeft },
+      { tx: c.x1, sx: s1 - trimRight }
+    );
+  }
+  return knots;
+}
+function warpX(knots, tx) {
+  const n = knots.length;
+  if (n === 0) {
+    return tx;
+  }
+  const first = knots[0];
+  const last = knots[n - 1];
+  if (tx <= first.tx) {
+    return first.sx + (tx - first.tx);
+  }
+  if (tx >= last.tx) {
+    return last.sx + (tx - last.tx);
+  }
+  let lo = 0;
+  let hi = n - 1;
+  while (hi - lo > 1) {
+    const mid = lo + hi >> 1;
+    if (knots[mid].tx <= tx) {
+      lo = mid;
+    } else {
+      hi = mid;
+    }
+  }
+  const a = knots[lo];
+  const b = knots[hi];
+  const span = b.tx - a.tx;
+  return span > 0 ? a.sx + (tx - a.tx) / span * (b.sx - a.sx) : a.sx;
+}
+
+export {
+  referenceKnots,
+  warpX
+};

package/dist/chunks/chunk-L3O7AWLI.js

@@ -0,0 +1,52 @@
+import {
+  placeOffReference
+} from "./chunk-TZFWUT2C.js";
+import {
+  ROW_HEIGHT_PX
+} from "./chunk-CPMHA4W5.js";
+import {
+  backboneNodes,
+  backbonePositions,
+  referenceSpan
+} from "./chunk-FYQWPEEY.js";
+
+// src/layout/anchoredLayout.ts
+function rankRows(graph) {
+  const present = /* @__PURE__ */ new Set();
+  for (const node of graph.nodes) {
+    if (node.stable) {
+      present.add(node.stable.rank);
+    }
+  }
+  return new Map([...present].sort((a, b) => a - b).map((r, i) => [r, i]));
+}
+function anchoredLayout(graph, region) {
+  const backbone = backboneNodes(graph);
+  if (backbone.length === 0) {
+    return void 0;
+  }
+  const span = referenceSpan(backbone, region);
+  const rows = rankRows(graph);
+  const nodePositions = backbonePositions(backbone);
+  const alleleDeletions = placeOffReference({
+    graph,
+    span,
+    rowY: (node) => (node.stable ? rows.get(node.stable.rank) ?? rows.size : rows.size) * ROW_HEIGHT_PX,
+    positions: nodePositions
+  });
+  const rowLabels = [...rows].map(([rank, row]) => ({
+    label: rank === 0 ? "Reference (rank 0)" : `Rank ${rank}`,
+    y: row * ROW_HEIGHT_PX
+  }));
+  return {
+    nodePositions,
+    rowLabels,
+    referenceAxis: true,
+    pixelRows: true,
+    alleleDeletions
+  };
+}
+
+export {
+  anchoredLayout
+};

package/dist/chunks/chunk-L5RYUPZI.js

@@ -0,0 +1,53 @@
+import {
+  clampZoom
+} from "./chunk-VKB57ZYE.js";
+
+// src/viewport.ts
+function axisScaleOf(scale, pixelRows) {
+  return { scaleX: scale, scaleY: pixelRows ? 1 : scale, pixelRows };
+}
+function viewportOf(t, axis, width, height) {
+  return {
+    minX: -t.translateX / axis.scaleX,
+    minY: -t.translateY / axis.scaleY,
+    maxX: (width - t.translateX) / axis.scaleX,
+    maxY: (height - t.translateY) / axis.scaleY
+  };
+}
+function padded(v, panes) {
+  const w = (v.maxX - v.minX) * panes;
+  const h = (v.maxY - v.minY) * panes;
+  return {
+    minX: v.minX - w,
+    minY: v.minY - h,
+    maxX: v.maxX + w,
+    maxY: v.maxY + h
+  };
+}
+function contains(outer, inner) {
+  return inner.minX >= outer.minX && inner.maxX <= outer.maxX && inner.minY >= outer.minY && inner.maxY <= outer.maxY;
+}
+function zoomAbout(t, factor, centerX, centerY, pixelRows) {
+  const scale = clampZoom(t.scale * factor);
+  const ratio = scale / t.scale;
+  return {
+    scale,
+    translateX: centerX - (centerX - t.translateX) * ratio,
+    translateY: pixelRows ? t.translateY : centerY - (centerY - t.translateY) * ratio
+  };
+}
+function screenToLayout(x, y, t, axis) {
+  return {
+    x: (x - t.translateX) / axis.scaleX,
+    y: (y - t.translateY) / axis.scaleY
+  };
+}
+
+export {
+  axisScaleOf,
+  viewportOf,
+  padded,
+  contains,
+  zoomAbout,
+  screenToLayout
+};