@jbrowse/bandage-core 6.0.1 → 6.0.3

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

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

package/dist/chunks/chunk-LOEA5IHZ.js

@@ -0,0 +1,71 @@
+import {
+  placeOffReference
+} from "./chunk-TZFWUT2C.js";
+import {
+  parsePanSN
+} from "./chunk-RVS2QCOX.js";
+import {
+  ROW_HEIGHT_PX
+} from "./chunk-CPMHA4W5.js";
+import {
+  backboneNodes,
+  backbonePositions,
+  isOffReference,
+  referenceSpan
+} from "./chunk-FYQWPEEY.js";
+
+// src/layout/sampleRowLayout.ts
+function contributingSamples(graph, keep) {
+  const carried = /* @__PURE__ */ new Map();
+  for (const node of graph.nodes) {
+    if (isOffReference(node)) {
+      const { sample } = parsePanSN(node.stable.refName);
+      carried.set(sample, (carried.get(sample) ?? 0) + node.length);
+    }
+  }
+  const held = new Map(keep.map((sample, row) => [sample, row]));
+  return [...carried.keys()].sort(
+    (a, b) => (held.get(a) ?? Infinity) - (held.get(b) ?? Infinity) || carried.get(b) - carried.get(a) || a.localeCompare(b)
+  );
+}
+function sampleRowLayout(graph, region, keep = []) {
+  const backbone = backboneNodes(graph);
+  const samples = contributingSamples(graph, keep);
+  if (backbone.length === 0 || samples.length === 0) {
+    return void 0;
+  }
+  const span = referenceSpan(backbone, region);
+  const rowOf = new Map(samples.map((s, i) => [s, i + 1]));
+  const nodePositions = backbonePositions(backbone);
+  const spareRow = samples.length + 1;
+  const alleleDeletions = placeOffReference({
+    graph,
+    span,
+    rowY: (node) => {
+      const stable = node.stable;
+      const row = stable ? rowOf.get(parsePanSN(stable.refName).sample) : void 0;
+      return (row ?? spareRow) * ROW_HEIGHT_PX;
+    },
+    positions: nodePositions
+  });
+  const referenceSample = parsePanSN(backbone[0].stable.refName).sample;
+  const rowLabels = [
+    { label: referenceSample, y: 0 },
+    ...samples.map((sample) => ({
+      label: sample,
+      y: rowOf.get(sample) * ROW_HEIGHT_PX
+    }))
+  ];
+  return {
+    nodePositions,
+    rowLabels,
+    sampleRows: samples,
+    referenceAxis: true,
+    pixelRows: true,
+    alleleDeletions
+  };
+}
+
+export {
+  sampleRowLayout
+};

package/dist/chunks/chunk-LTUWJKHD.js

@@ -0,0 +1,112 @@
+import {
+  joinCuts
+} from "./chunk-WSIFAZU7.js";
+import {
+  wellKnownSample
+} from "./chunk-RAKOB6IV.js";
+import {
+  panSNMatchesPrefix,
+  panSNSample
+} from "./chunk-BPLIXMH7.js";
+
+// src/gbzWindow.ts
+var NoReferenceSampleError = class extends Error {
+  constructor(anchor, referenceSamples) {
+    super(
+      referenceSamples.length === 0 ? `the graph names no reference sample (gbwt_reference_samples) and the anchor "${anchor}" maps to none; set referenceSample` : `the anchor "${anchor}" is none of the graph's reference samples (${referenceSamples.join(", ")}); set referenceSample or map it through assemblyNameToPanSN`
+    );
+    this.name = "NoReferenceSampleError";
+  }
+};
+var NodeLimitError = class extends Error {
+  constructor(limit, windowBp, fitsBp) {
+    super(
+      `this ${windowBp.toLocaleString()} bp window reads more than nodeLimit (${limit.toLocaleString()}) graph nodes; zoom in to about ${fitsBp.toLocaleString()} bp or raise nodeLimit`
+    );
+    this.fitsBp = fitsBp;
+    this.name = "NodeLimitError";
+    this.regionTooLarge = true;
+  }
+};
+function haplotypePrefix(name) {
+  return `${name.sample}#${name.haplotype}`;
+}
+function haplotypeWanted(name, wanted) {
+  const prefix = haplotypePrefix(name);
+  return wanted === void 0 || wanted.some((candidate) => panSNMatchesPrefix(prefix, candidate));
+}
+async function referenceSamplesOf(db) {
+  return (await db.tag("gbwt_reference_samples") ?? "").split(/\s+/).filter((sample) => sample !== "");
+}
+function aliasedSample(anchorSample, referenceSamples) {
+  const lower = anchorSample.toLowerCase();
+  const alias = wellKnownSample(anchorSample)?.toLowerCase();
+  return referenceSamples.find((s) => s === anchorSample) ?? referenceSamples.find((s) => s.toLowerCase() === lower) ?? referenceSamples.find((s) => s.toLowerCase() === alias);
+}
+function resolveReferenceSample({
+  configured,
+  anchorPrefix,
+  referenceSamples
+}) {
+  if (configured !== "") {
+    return configured;
+  }
+  const sample = aliasedSample(panSNSample(anchorPrefix), referenceSamples) ?? (referenceSamples.length === 1 ? referenceSamples[0] : void 0);
+  if (sample === void 0) {
+    throw new NoReferenceSampleError(anchorPrefix, referenceSamples);
+  }
+  return sample;
+}
+async function referencePathQuery(db, referenceSample, refName) {
+  const path = (await db.paths()).find(
+    (p) => p.isIndexed && p.name.sample === referenceSample && p.name.contig === refName
+  );
+  return path ? {
+    sample: path.name.sample,
+    contig: refName,
+    haplotype: path.name.haplotype
+  } : void 0;
+}
+function nodeLimitError(error, limit, windowBp) {
+  const isLimit = error instanceof Error && (error.name === "SubgraphLimitError" || /^Subgraph size limit of \d+ nodes exceeded/.test(error.message));
+  if (!isLimit) {
+    return void 0;
+  } else {
+    const walked = error.walkedBp;
+    const fits = typeof walked === "number" && walked > 0 ? Math.floor(walked * 0.8) : Math.floor(windowBp / 2);
+    return new NodeLimitError(limit, windowBp, Math.max(fits, 1));
+  }
+}
+var GBZ_CUT_DEFAULTS = {
+  context: 1e3,
+  snarls: "contained",
+  limit: 1e5
+};
+async function cutWindowGFA(db, query, start, end, opts) {
+  if (!query) {
+    return "";
+  }
+  const subgraphs = await db.getSubgraphs({ ...opts, path: query, start, end, haplotypes: "all" }).catch((error) => {
+    throw nodeLimitError(error, opts.limit, end - start) ?? error;
+  });
+  const paths = await db.paths();
+  return joinCuts(
+    await Promise.all(subgraphs.map((subgraph) => subgraph.toGFA())),
+    (sample, haplotype, contig, at) => paths.some(
+      ({ name }) => name.sample === sample && name.haplotype === haplotype && name.contig === contig && name.fragment === at
+    )
+  );
+}
+
+export {
+  NoReferenceSampleError,
+  NodeLimitError,
+  haplotypePrefix,
+  haplotypeWanted,
+  referenceSamplesOf,
+  resolveReferenceSample,
+  referencePathQuery,
+  nodeLimitError,
+  GBZ_CUT_DEFAULTS,
+  cutWindowGFA
+};

package/dist/chunks/chunk-MFKORG3F.js

@@ -0,0 +1,44 @@
+// src/bubbles/bubbleLine.ts
+function sequence(field) {
+  return field === void 0 || field === "*" ? void 0 : field;
+}
+function parseBubbleLine(line) {
+  const cols = line.split("	");
+  return {
+    refName: cols[0],
+    start: +cols[1],
+    end: +cols[2],
+    segmentCount: +cols[3],
+    pathCount: +cols[4],
+    inversion: cols[5] === "1",
+    shortestAlleleLength: +cols[6],
+    longestAlleleLength: +cols[7],
+    segments: cols[11],
+    shortestAllele: sequence(cols[12]),
+    longestAllele: sequence(cols[13])
+  };
+}
+function sameBubble(a, b) {
+  return a.refName === b.refName && a.start === b.start && a.end === b.end;
+}
+function bubbleLabel(bubble) {
+  const { shortestAlleleLength: min, longestAlleleLength: max } = bubble;
+  return min === max ? `${max.toLocaleString()} bp` : `${min.toLocaleString()}-${max.toLocaleString()} bp`;
+}
+var SATURATED_PATH_COUNT = 2147483647;
+function bubbleDescription(bubble) {
+  const { pathCount, segmentCount, inversion } = bubble;
+  return [
+    `${segmentCount} segments`,
+    pathCount === SATURATED_PATH_COUNT ? "more paths than gfatools counts" : `up to ${pathCount.toLocaleString()} paths`,
+    ...inversion ? ["inversion"] : []
+  ].join(", ");
+}
+
+export {
+  parseBubbleLine,
+  sameBubble,
+  bubbleLabel,
+  SATURATED_PATH_COUNT,
+  bubbleDescription
+};

package/dist/chunks/chunk-MI35EUIE.js

@@ -0,0 +1,76 @@
+// src/layout/deletionRoutes.ts
+var ROUTE_ID = "\0deletion:";
+var ROUTE_FRACTION = 0.5;
+function withDeletionRoutes(graph, deletions) {
+  const routes = new Map(
+    deletions.map((d) => [d.edgeIndex, `${ROUTE_ID}${d.edgeIndex}`])
+  );
+  const edges = [];
+  graph.edges.forEach((edge, ei) => {
+    const id = routes.get(ei);
+    if (id === void 0) {
+      edges.push(edge);
+    } else {
+      const { fromStrand, toStrand } = edge;
+      edges.push(
+        { from: edge.from, to: id, ...fromStrand ? { fromStrand } : {} },
+        { from: id, to: edge.to, ...toStrand ? { toStrand } : {} }
+      );
+    }
+  });
+  return {
+    graph: {
+      ...graph,
+      nodes: [
+        ...graph.nodes,
+        ...[...routes.values()].map((id) => ({
+          id,
+          name: id,
+          length: 0,
+          depth: 0
+        }))
+      ],
+      edges
+    },
+    routes,
+    ids: new Set(routes.values())
+  };
+}
+function routeNodes(graph, deletions, routes, drawnOf, opts) {
+  const lengths = new Map(graph.nodes.map((n) => [n.id, n.length]));
+  return deletions.map((d) => {
+    const skipped = d.bypassed.reduce(
+      (sum, id2) => sum + (lengths.get(id2) ?? 0),
+      0
+    );
+    const drawn = Math.max(
+      opts.minimumNodeLength,
+      drawnOf(skipped) * ROUTE_FRACTION
+    );
+    const id = routes.get(d.edgeIndex);
+    return {
+      id,
+      name: id,
+      length: Math.round(drawn * 1e6 / opts.nodeLengthPerMegabase),
+      depth: 0
+    };
+  });
+}
+function takeRoutes(positions, routes) {
+  const nodePositions = { ...positions };
+  const deletionRoutes = {};
+  for (const [edgeIndex, id] of routes) {
+    const route = nodePositions[id];
+    delete nodePositions[id];
+    if (route?.length) {
+      deletionRoutes[edgeIndex] = route;
+    }
+  }
+  return { nodePositions, deletionRoutes };
+}
+
+export {
+  withDeletionRoutes,
+  routeNodes,
+  takeRoutes
+};

package/dist/chunks/chunk-MNUSQCLG.js

@@ -0,0 +1,29 @@
+// src/renderer/colorBits.ts
+import {
+  abgrAlpha,
+  abgrBlue,
+  abgrGreen,
+  abgrRed,
+  packAbgr
+} from "@jbrowse/core/util/colorBits";
+function fadeAbgr(c, alpha) {
+  return packAbgr(
+    abgrRed(c),
+    abgrGreen(c),
+    abgrBlue(c),
+    Math.round(abgrAlpha(c) * alpha)
+  );
+}
+function brightenAbgr(c, factor) {
+  return packAbgr(
+    Math.min(255, Math.round(abgrRed(c) * factor)),
+    Math.min(255, Math.round(abgrGreen(c) * factor)),
+    Math.min(255, Math.round(abgrBlue(c) * factor)),
+    abgrAlpha(c)
+  );
+}
+
+export {
+  fadeAbgr,
+  brightenAbgr
+};

package/dist/chunks/chunk-MQJUG2D2.js

@@ -0,0 +1,53 @@
+import {
+  clampZoom
+} from "./chunk-IO2PCPZI.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
+};

package/dist/chunks/chunk-MREQ7GIA.js

@@ -0,0 +1,181 @@
+import {
+  baseEdgeCurves
+} from "./chunk-Y3IOTZJA.js";
+import {
+  curveBounds,
+  pathRibbonOffsets
+} from "./chunk-2CVHXFK7.js";
+
+// src/util/SpatialIndex.ts
+var FALLBACK_CELL_SIZE = 50;
+function meanExtentCellSize(extentTotal, count) {
+  return count > 0 ? Math.max(1, extentTotal / count) : FALLBACK_CELL_SIZE;
+}
+function rowPitchOf(boxes) {
+  const distinct = /* @__PURE__ */ new Set();
+  let min = Infinity;
+  let max = -Infinity;
+  for (const box of boxes) {
+    distinct.add(box.minY);
+    min = Math.min(min, box.minY);
+    max = Math.max(max, box.minY);
+  }
+  return distinct.size > 1 ? (max - min) / (distinct.size - 1) : void 0;
+}
+function cellSizeFrom(boxes, extentX, extentY) {
+  const x = meanExtentCellSize(extentX, boxes.length);
+  return {
+    x,
+    y: extentY > 0 ? meanExtentCellSize(extentY, boxes.length) : rowPitchOf(boxes) ?? x
+  };
+}
+function resolveCellSize(given, boxes, extentX, extentY) {
+  return given === void 0 ? cellSizeFrom(boxes, extentX, extentY) : typeof given === "number" ? { x: given, y: given } : given;
+}
+function getOrCreateCell(cells, cx, cy) {
+  let row = cells.get(cx);
+  if (!row) {
+    row = /* @__PURE__ */ new Map();
+    cells.set(cx, row);
+  }
+  let cell = row.get(cy);
+  if (!cell) {
+    cell = [];
+    row.set(cy, cell);
+  }
+  return cell;
+}
+function addToGrid(cells, cellSize, minX, minY, maxX, maxY, entry) {
+  const cx0 = Math.floor(minX / cellSize.x);
+  const cx1 = Math.floor(maxX / cellSize.x);
+  const cy0 = Math.floor(minY / cellSize.y);
+  const cy1 = Math.floor(maxY / cellSize.y);
+  for (let cx = cx0; cx <= cx1; cx++) {
+    for (let cy = cy0; cy <= cy1; cy++) {
+      getOrCreateCell(cells, cx, cy).push(entry);
+    }
+  }
+}
+function queryGrid(cells, cellSize, x, y, radiusX, radiusY) {
+  const cx0 = Math.floor((x - radiusX) / cellSize.x);
+  const cx1 = Math.floor((x + radiusX) / cellSize.x);
+  const cy0 = Math.floor((y - radiusY) / cellSize.y);
+  const cy1 = Math.floor((y + radiusY) / cellSize.y);
+  const results = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (let cx = cx0; cx <= cx1; cx++) {
+    const row = cells.get(cx);
+    if (row) {
+      for (let cy = cy0; cy <= cy1; cy++) {
+        const cell = row.get(cy);
+        if (cell) {
+          for (const entry of cell) {
+            if (!seen.has(entry)) {
+              seen.add(entry);
+              results.push(entry);
+            }
+          }
+        }
+      }
+    }
+  }
+  return results;
+}
+var SpatialIndex = class {
+  constructor(nodePositions, cellSize) {
+    this.cells = /* @__PURE__ */ new Map();
+    const boxes = [];
+    let extentX = 0;
+    let extentY = 0;
+    for (const [nodeId, segments] of Object.entries(nodePositions)) {
+      for (let i = 0; i < segments.length - 1; i++) {
+        const seg = segments[i];
+        const next = segments[i + 1];
+        const minX = Math.min(seg.x, next.x);
+        const minY = Math.min(seg.y, next.y);
+        const maxX = Math.max(seg.x, next.x);
+        const maxY = Math.max(seg.y, next.y);
+        extentX += maxX - minX;
+        extentY += maxY - minY;
+        boxes.push({ entry: { nodeId, segmentIdx: i }, minX, minY, maxX, maxY });
+      }
+    }
+    this.cellSize = resolveCellSize(cellSize, boxes, extentX, extentY);
+    for (const b of boxes) {
+      addToGrid(
+        this.cells,
+        this.cellSize,
+        b.minX,
+        b.minY,
+        b.maxX,
+        b.maxY,
+        b.entry
+      );
+    }
+  }
+  query(x, y, radiusX, radiusY = radiusX) {
+    return queryGrid(this.cells, this.cellSize, x, y, radiusX, radiusY);
+  }
+};
+var EdgeSpatialIndex = class {
+  constructor(nodePositions, graph, drawPaths, axis, cellSize, deletions, version = 0, routes, stranded = false) {
+    this.cells = /* @__PURE__ */ new Map();
+    this.edgeCurves = baseEdgeCurves(
+      nodePositions,
+      graph,
+      axis,
+      deletions,
+      version,
+      routes,
+      stranded
+    );
+    const boxes = [];
+    let extentX = 0;
+    let extentY = 0;
+    for (let ei = 0; ei < graph.edges.length; ei++) {
+      const edge = graph.edges[ei];
+      const fromSegments = nodePositions[edge.from];
+      const toSegments = nodePositions[edge.to];
+      const curves = this.edgeCurves.get(ei);
+      if (fromSegments?.length && toSegments?.length && curves) {
+        let { minX, minY, maxX, maxY } = curveBounds(curves);
+        const numPaths = edge.pathIds?.length ?? 0;
+        if (drawPaths && numPaths > 0) {
+          let padX = 0;
+          let padY = 0;
+          for (const o of pathRibbonOffsets(
+            fromSegments,
+            toSegments,
+            numPaths,
+            axis
+          )) {
+            padX = Math.max(padX, Math.abs(o.x));
+            padY = Math.max(padY, Math.abs(o.y));
+          }
+          minX -= padX;
+          minY -= padY;
+          maxX += padX;
+          maxY += padY;
+        }
+        extentX += maxX - minX;
+        extentY += maxY - minY;
+        boxes.push({ ei, minX, minY, maxX, maxY });
+      }
+    }
+    this.cellSize = resolveCellSize(cellSize, boxes, extentX, extentY);
+    for (const b of boxes) {
+      addToGrid(this.cells, this.cellSize, b.minX, b.minY, b.maxX, b.maxY, b.ei);
+    }
+  }
+  getCurves(ei) {
+    return this.edgeCurves.get(ei);
+  }
+  query(x, y, radiusX, radiusY = radiusX) {
+    return queryGrid(this.cells, this.cellSize, x, y, radiusX, radiusY);
+  }
+};
+
+export {
+  SpatialIndex,
+  EdgeSpatialIndex
+};