@weasel-js/diagram 1.11.0 → 1.11.1

package/dist/chunk-T6DQT553.js

@@ -0,0 +1,1431 @@
+import { labelCenter, samePoints } from './chunk-IM6DHWZO.js';
+import { polylineFromPoints } from '@weasel-js/core/math';
+
+// src/hops/types.ts
+var HOPS_DOC_KEY = "diagram:hops";
+var DEFAULT_HOP_SIZE = 5;
+
+// src/polyline.ts
+var EPS = 1e-6;
+var same = (a, b) => Math.abs(a.x - b.x) <= EPS && Math.abs(a.y - b.y) <= EPS;
+function simplifyStops(points) {
+  const out = [];
+  for (const p of points) {
+    if (out.length > 0 && same(out[out.length - 1], p)) continue;
+    while (out.length >= 2 && between(out[out.length - 2], out[out.length - 1], p)) out.pop();
+    out.push(p);
+  }
+  return out;
+}
+function between(a, m, b) {
+  const cross = (m.x - a.x) * (b.y - a.y) - (m.y - a.y) * (b.x - a.x);
+  const dot = (m.x - a.x) * (b.x - m.x) + (m.y - a.y) * (b.y - m.y);
+  return Math.abs(cross) <= EPS && dot > 0;
+}
+
+// src/avoid/types.ts
+var AVOID_DEFAULTS = Object.freeze({
+  clearance: 10,
+  bendPenalty: 40,
+  crossPenalty: 20,
+  spacing: 8,
+  margin: 100,
+  labelClearance: 4
+});
+var inflate = (box, by) => ({ x: box.x - by, y: box.y - by, width: box.width + 2 * by, height: box.height + 2 * by });
+function blocks(obstacle, edge) {
+  if (obstacle.kind === "shape") return true;
+  if (obstacle.kind === "label") return obstacle.edge !== edge.id;
+  const members = obstacle.members;
+  return members === void 0 || !members.has(edge.from.node) && !members.has(edge.to.node);
+}
+
+// src/avoid/hash.ts
+var CELL = 128;
+var SpatialHash = class _SpatialHash {
+  constructor(cell = CELL) {
+    this.cell = cell;
+  }
+  cell;
+  cells = /* @__PURE__ */ new Map();
+  query_ = 0;
+  /** The key of cell `(i, j)`. Packs both into one number for the map. */
+  static key(i, j) {
+    return (i + 32768) * 65536 + (j + 32768);
+  }
+  range(box) {
+    const c = this.cell;
+    return [Math.floor(box.x / c), Math.floor(box.y / c), Math.floor((box.x + box.width) / c), Math.floor((box.y + box.height) / c)];
+  }
+  insert(item, box) {
+    const filed = { item, seen: 0 };
+    const [i0, j0, i1, j1] = this.range(box);
+    for (let i = i0; i <= i1; i++) {
+      for (let j = j0; j <= j1; j++) {
+        const k = _SpatialHash.key(i, j);
+        const list = this.cells.get(k);
+        if (list === void 0) this.cells.set(k, [filed]);
+        else list.push(filed);
+      }
+    }
+  }
+  /** Take `item`, filed under `box`, back out. */
+  remove(item, box) {
+    const [i0, j0, i1, j1] = this.range(box);
+    for (let i = i0; i <= i1; i++) {
+      for (let j = j0; j <= j1; j++) {
+        const list = this.cells.get(_SpatialHash.key(i, j));
+        const at = list?.findIndex((f) => f.item === item) ?? -1;
+        if (at >= 0) list.splice(at, 1);
+      }
+    }
+  }
+  /** Every item filed in a cell `box` touches, each once. */
+  query(box, out = []) {
+    const [i0, j0, i1, j1] = this.range(box);
+    const stamp = ++this.query_;
+    for (let i = i0; i <= i1; i++) {
+      for (let j = j0; j <= j1; j++) {
+        const list = this.cells.get(_SpatialHash.key(i, j));
+        if (list === void 0) continue;
+        for (const filed of list) {
+          if (filed.seen === stamp) continue;
+          filed.seen = stamp;
+          out.push(filed.item);
+        }
+      }
+    }
+    return out;
+  }
+};
+
+// src/avoid/segments.ts
+var EPS2 = 1e-7;
+var boxOf = (s) => ({
+  x: Math.min(s.x0, s.x1),
+  y: Math.min(s.y0, s.y1),
+  width: Math.abs(s.x1 - s.x0),
+  height: Math.abs(s.y1 - s.y0)
+});
+function touches(s, box) {
+  const b = boxOf(s);
+  return b.x <= box.x + box.width && box.x <= b.x + b.width && b.y <= box.y + box.height && box.y <= b.y + b.height;
+}
+var SegmentIndex = class {
+  hash = new SpatialHash();
+  scratch = [];
+  /** File every segment of `points`, connector `edge`'s polyline. */
+  add(edge, points) {
+    for (let i = 0; i + 1 < points.length; i++) {
+      const a = points[i];
+      const b = points[i + 1];
+      const s = { edge, x0: a.x, y0: a.y, x1: b.x, y1: b.y };
+      this.hash.insert(s, boxOf(s));
+    }
+  }
+  /** The connectors with a segment touching `box`. */
+  edgesMeeting(box, into) {
+    for (const s of this.hash.query(box)) if (touches(s, box)) into.add(s.edge);
+  }
+  /** How many segments of connectors other than `self` the axis-aligned step
+   *  from `(x0, y0)` to `(x1, y1)` crosses at right angles. */
+  crossings(self, x0, y0, x1, y1) {
+    const lx = Math.min(x0, x1);
+    const hx = Math.max(x0, x1);
+    const ly = Math.min(y0, y1);
+    const hy = Math.max(y0, y1);
+    const horizontal = ly === hy;
+    this.scratch.length = 0;
+    let n = 0;
+    for (const s of this.hash.query({ x: lx, y: ly, width: hx - lx, height: hy - ly }, this.scratch)) {
+      if (s.edge === self) continue;
+      if (horizontal) {
+        if (Math.abs(s.x0 - s.x1) > EPS2) continue;
+        const sl = Math.min(s.y0, s.y1);
+        const sh = Math.max(s.y0, s.y1);
+        if (s.x0 > lx + EPS2 && s.x0 < hx - EPS2 && ly > sl + EPS2 && ly < sh - EPS2) n++;
+      } else {
+        if (Math.abs(s.y0 - s.y1) > EPS2) continue;
+        const sl = Math.min(s.x0, s.x1);
+        const sh = Math.max(s.x0, s.x1);
+        if (s.y0 > ly + EPS2 && s.y0 < hy - EPS2 && lx > sl + EPS2 && lx < sh - EPS2) n++;
+      }
+    }
+    return n;
+  }
+};
+
+// src/avoid/dirty.ts
+var sameBox = (a, b) => a.x === b.x && a.y === b.y && a.width === b.width && a.height === b.height;
+function sameObstacle(a, b) {
+  if (a.kind !== b.kind || !sameBox(a.box, b.box)) return false;
+  const am = a.members;
+  const bm = b.members;
+  if (am === bm) return true;
+  if (am === void 0 || bm === void 0 || am.size !== bm.size) return false;
+  for (const id of am) if (!bm.has(id)) return false;
+  return true;
+}
+function changedObstacles(before, now2) {
+  const ids = /* @__PURE__ */ new Set();
+  const boxes = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const o of now2) {
+    seen.add(o.id);
+    const was = before.get(o.id);
+    if (was !== void 0 && sameObstacle(was, o)) continue;
+    ids.add(o.id);
+    boxes.push(o.box);
+    if (was !== void 0) boxes.push(was.box);
+  }
+  for (const [id, was] of before) {
+    if (seen.has(id)) continue;
+    ids.add(id);
+    boxes.push(was.box);
+  }
+  return { ids, boxes };
+}
+var portKey = (p) => `${p.point.x},${p.point.y},${p.normal.x},${p.normal.y}`;
+var stopsKey = (e) => `${e.from.node}:${e.from.ports.map(portKey).join(";")}|${e.to.node}:${e.to.ports.map(portKey).join(";")}|${(e.waypoints ?? []).map((w) => `${w.x},${w.y}`).join(";")}`;
+function facing(ports, toward) {
+  let best;
+  let score = -Infinity;
+  for (const p of ports) {
+    const dx = toward.x - p.point.x;
+    const dy = toward.y - p.point.y;
+    const len = Math.hypot(dx, dy) || 1;
+    const s = (p.normal.x * dx + p.normal.y * dy) / len - len / 1e6;
+    if (s > score) {
+      score = s;
+      best = p;
+    }
+  }
+  return best;
+}
+var centroid = (ports) => ({
+  x: ports.reduce((s, p) => s + p.point.x, 0) / Math.max(1, ports.length),
+  y: ports.reduce((s, p) => s + p.point.y, 0) / Math.max(1, ports.length)
+});
+function fullRoute(edge) {
+  const route = edge.route ?? [];
+  const from = facing(edge.from.ports, route[0] ?? centroid(edge.to.ports));
+  const to = facing(edge.to.ports, route[route.length - 1] ?? centroid(edge.from.ports));
+  return [...from ? [from.point] : [], ...route, ...to ? [to.point] : []];
+}
+function dirtyEdges(edges, keys, changed, clearance, routes) {
+  const first = [];
+  const meeting = /* @__PURE__ */ new Set();
+  if (changed.boxes.length > 0) {
+    const index = new SegmentIndex();
+    for (const e of edges) index.add(e.id, routes(e));
+    for (const box of changed.boxes) index.edgesMeeting(inflate(box, clearance), meeting);
+  }
+  const rest = [];
+  for (const e of edges) {
+    const attached = changed.ids.has(e.from.node) || changed.ids.has(e.to.node);
+    if (attached || keys.get(e.id) !== stopsKey(e) || e.route === void 0) first.push(e);
+    else if (meeting.has(e.id)) rest.push(e);
+  }
+  return [...first, ...rest];
+}
+
+// src/avoid/obstacles.ts
+var EPS3 = 1e-7;
+var ObstacleIndex = class {
+  constructor(obstacles, clearance, labelClearance = clearance) {
+    this.clearance = clearance;
+    this.labelClearance = labelClearance;
+    for (const obstacle of obstacles) this.file(obstacle);
+  }
+  clearance;
+  labelClearance;
+  byId = /* @__PURE__ */ new Map();
+  hash = new SpatialHash();
+  file(obstacle) {
+    const item = { obstacle, box: inflate(obstacle.box, obstacle.kind === "label" ? this.labelClearance : this.clearance) };
+    this.byId.set(obstacle.id, item);
+    this.hash.insert(item, item.box);
+  }
+  /** Obstacle `id` as filed, inflated. */
+  get(id) {
+    return this.byId.get(id);
+  }
+  /** File `obstacle` in place of the one with its id, which leaves the hash. */
+  replace(obstacle) {
+    const old = this.byId.get(obstacle.id);
+    if (old !== void 0) this.hash.remove(old, old.box);
+    this.file(obstacle);
+  }
+  /** The inflated obstacles touching `box`. */
+  near(box, out = []) {
+    return this.hash.query(box, out);
+  }
+  /** Remove obstacle `id`, if it is filed. */
+  delete(id) {
+    const old = this.byId.get(id);
+    if (old === void 0) return;
+    this.hash.remove(old, old.box);
+    this.byId.delete(id);
+  }
+  /** A view of the index for connector `edge`. */
+  forEdge(edge) {
+    return new EdgeObstacles(this, edge);
+  }
+};
+var EdgeObstacles = class {
+  constructor(index, edge) {
+    this.index = index;
+    this.edge = edge;
+  }
+  index;
+  edge;
+  scratch = [];
+  /** The inflated boxes blocking this connector that touch `box`. */
+  near(box) {
+    this.scratch.length = 0;
+    const out = [];
+    for (const o of this.index.near(box, this.scratch)) if (blocks(o.obstacle, this.edge)) out.push(o.box);
+    return out;
+  }
+  /** Whether `(x, y)` lies strictly inside a blocking obstacle. */
+  inside(x, y) {
+    this.scratch.length = 0;
+    for (const o of this.index.near({ x, y, width: 0, height: 0 }, this.scratch)) {
+      const b = o.box;
+      if (x > b.x + EPS3 && x < b.x + b.width - EPS3 && y > b.y + EPS3 && y < b.y + b.height - EPS3 && blocks(o.obstacle, this.edge)) return true;
+    }
+    return false;
+  }
+  /** Whether the axis-aligned step from `(x0, y0)` to `(x1, y1)` crosses a
+   *  blocking obstacle's interior. */
+  crosses(x0, y0, x1, y1) {
+    const lx = Math.min(x0, x1);
+    const hx = Math.max(x0, x1);
+    const ly = Math.min(y0, y1);
+    const hy = Math.max(y0, y1);
+    this.scratch.length = 0;
+    for (const o of this.index.near({ x: lx, y: ly, width: hx - lx, height: hy - ly }, this.scratch)) {
+      const b = o.box;
+      if (hx > b.x + EPS3 && lx < b.x + b.width - EPS3 && hy > b.y + EPS3 && ly < b.y + b.height - EPS3 && blocks(o.obstacle, this.edge)) return true;
+    }
+    return false;
+  }
+};
+
+// src/avoid/dragIndex.ts
+var sameBox2 = (a, b) => a.x === b.x && a.y === b.y && a.width === b.width && a.height === b.height;
+function union(a, b) {
+  const x = Math.min(a.x, b.x);
+  const y = Math.min(a.y, b.y);
+  return { x, y, width: Math.max(a.x + a.width, b.x + b.width) - x, height: Math.max(a.y + a.height, b.y + b.height) - y };
+}
+var DragIndex = class {
+  constructor(input, routes, clearance, limit) {
+    this.clearance = clearance;
+    this.limit = limit;
+    for (const o of input.obstacles) this.committed.set(o.id, o);
+    this.index = new ObstacleIndex(input.obstacles, clearance);
+    for (const e of input.edges) {
+      for (const node of /* @__PURE__ */ new Set([e.from.node, e.to.node])) {
+        const list = this.attached.get(node);
+        if (list === void 0) this.attached.set(node, [e.id]);
+        else list.push(e.id);
+      }
+      const route = routes.get(e.id);
+      if (route !== void 0) this.segments.add(e.id, route);
+    }
+  }
+  clearance;
+  limit;
+  committed = /* @__PURE__ */ new Map();
+  /** The obstacles this frame has moved off their committed place, as they now are. */
+  displaced = /* @__PURE__ */ new Map();
+  index;
+  segments = new SegmentIndex();
+  attached = /* @__PURE__ */ new Map();
+  /** Swap this frame's obstacles into the index where they moved, and answer
+   *  what it reroutes. Diffs the frame's obstacles against the last frame's;
+   *  touches the hash and the connectors only for the ones that moved. */
+  frame(obstacles) {
+    const seen = /* @__PURE__ */ new Set();
+    for (const o of obstacles) {
+      const base = this.committed.get(o.id);
+      if (base === void 0) continue;
+      const now2 = this.displaced.get(o.id) ?? base;
+      if (sameBox2(now2.box, o.box)) {
+        if (this.displaced.has(o.id)) seen.add(o.id);
+        continue;
+      }
+      this.index.replace(o);
+      if (sameBox2(base.box, o.box)) this.displaced.delete(o.id);
+      else {
+        this.displaced.set(o.id, o);
+        seen.add(o.id);
+      }
+    }
+    for (const [id] of this.displaced) {
+      if (seen.has(id)) continue;
+      this.index.replace(this.committed.get(id));
+      this.displaced.delete(id);
+    }
+    const first = /* @__PURE__ */ new Set();
+    const meeting = /* @__PURE__ */ new Set();
+    let limit = this.limit;
+    for (const [id, o] of this.displaced) {
+      for (const e of this.attached.get(id) ?? []) first.add(e);
+      this.segments.edgesMeeting(inflate(this.committed.get(id).box, this.clearance), meeting);
+      this.segments.edgesMeeting(inflate(o.box, this.clearance), meeting);
+      limit = union(limit, o.box);
+    }
+    return { index: this.index, dirty: [...first, ...[...meeting].filter((e) => !first.has(e))], limit };
+  }
+};
+function labelObstacle(edge, route) {
+  const label = edge.label;
+  if (label === void 0 || route.length < 2) return null;
+  const center = labelCenter(polylineFromPoints(route), label.placement, label.size);
+  if (center === null) return null;
+  const { width, height } = label.size;
+  return { id: label.id, kind: "label", edge: edge.id, box: { x: center.x - width / 2, y: center.y - height / 2, width, height } };
+}
+function labelObstacles(edges, routeOf) {
+  const out = [];
+  for (const edge of edges) {
+    if (edge.label === void 0) continue;
+    const o = labelObstacle(edge, routeOf(edge));
+    if (o !== null) out.push(o);
+  }
+  return out;
+}
+
+// src/avoid/grid.ts
+var EPS4 = 1e-7;
+function searchWindow(points, margin) {
+  let x0 = Infinity;
+  let y0 = Infinity;
+  let x1 = -Infinity;
+  let y1 = -Infinity;
+  for (const p of points) {
+    x0 = Math.min(x0, p.x);
+    y0 = Math.min(y0, p.y);
+    x1 = Math.max(x1, p.x);
+    y1 = Math.max(y1, p.y);
+  }
+  return { x: x0 - margin, y: y0 - margin, width: x1 - x0 + 2 * margin, height: y1 - y0 + 2 * margin };
+}
+var within = (inner, outer) => inner.x >= outer.x && inner.y >= outer.y && inner.x + inner.width <= outer.x + outer.width && inner.y + inner.height <= outer.y + outer.height;
+var holds = (box, p) => p.x >= box.x - EPS4 && p.x <= box.x + box.width + EPS4 && p.y >= box.y - EPS4 && p.y <= box.y + box.height + EPS4;
+function firstPast(sorted, v, key) {
+  let lo = 0;
+  let hi = sorted.length;
+  while (lo < hi) {
+    const mid = lo + hi >> 1;
+    if (key(sorted[mid]) <= v) lo = mid + 1;
+    else hi = mid;
+  }
+  return lo;
+}
+function channelMiddles(boxes, axis) {
+  const lo = (b) => axis === "x" ? b.x : b.y;
+  const size = (b) => axis === "x" ? b.width : b.height;
+  const crossLo = (b) => axis === "x" ? b.y : b.x;
+  const crossHi = (b) => axis === "x" ? b.y + b.height : b.x + b.width;
+  const sorted = [...boxes].sort((a, b) => lo(a) - lo(b));
+  const out = [];
+  for (const a of sorted) {
+    const end = lo(a) + size(a);
+    let k = firstPast(sorted, end, lo);
+    let nearest = null;
+    for (; k < sorted.length && nearest === null; k++) {
+      const b = sorted[k];
+      if (crossLo(a) < crossHi(b) && crossLo(b) < crossHi(a)) nearest = b;
+    }
+    if (nearest === null) continue;
+    const along2 = (end + lo(nearest)) / 2;
+    const across2 = (Math.max(crossLo(a), crossLo(nearest)) + Math.min(crossHi(a), crossHi(nearest))) / 2;
+    out.push(axis === "x" ? { x: along2, y: across2 } : { x: across2, y: along2 });
+  }
+  return out;
+}
+function interestingPoints(window, boxes, ends) {
+  const out = [...ends];
+  for (const b of boxes) {
+    for (const p of [
+      { x: b.x, y: b.y },
+      { x: b.x + b.width, y: b.y },
+      { x: b.x, y: b.y + b.height },
+      { x: b.x + b.width, y: b.y + b.height }
+    ]) if (holds(window, p)) out.push(p);
+  }
+  for (const p of [...channelMiddles(boxes, "x"), ...channelMiddles(boxes, "y")]) if (holds(window, p)) out.push(p);
+  return out;
+}
+
+// src/avoid/heap.ts
+var MinHeap = class {
+  ids = [];
+  keys = [];
+  ties = [];
+  get size() {
+    return this.ids.length;
+  }
+  less(a, b) {
+    const ka = this.keys[a];
+    const kb = this.keys[b];
+    return ka < kb || ka === kb && this.ties[a] < this.ties[b];
+  }
+  swap(a, b) {
+    const id = this.ids[a];
+    this.ids[a] = this.ids[b];
+    this.ids[b] = id;
+    const key = this.keys[a];
+    this.keys[a] = this.keys[b];
+    this.keys[b] = key;
+    const tie = this.ties[a];
+    this.ties[a] = this.ties[b];
+    this.ties[b] = tie;
+  }
+  push(id, key, tie) {
+    this.ids.push(id);
+    this.keys.push(key);
+    this.ties.push(tie);
+    let i = this.ids.length - 1;
+    while (i > 0) {
+      const parent = i - 1 >> 1;
+      if (!this.less(i, parent)) break;
+      this.swap(i, parent);
+      i = parent;
+    }
+  }
+  /** The id with the least key, removed. Undefined when empty. */
+  pop() {
+    const n = this.ids.length;
+    if (n === 0) return void 0;
+    const top = this.ids[0];
+    this.swap(0, n - 1);
+    this.ids.pop();
+    this.keys.pop();
+    this.ties.pop();
+    let i = 0;
+    for (; ; ) {
+      const l = 2 * i + 1;
+      const r = l + 1;
+      let m = i;
+      if (l < n - 1 && this.less(l, m)) m = l;
+      if (r < n - 1 && this.less(r, m)) m = r;
+      if (m === i) break;
+      this.swap(i, m);
+      i = m;
+    }
+    return top;
+  }
+};
+
+// src/avoid/turns.ts
+function dirOf(v) {
+  if (Math.abs(v.x) >= Math.abs(v.y)) return v.x >= 0 ? 0 : 2;
+  return v.y >= 0 ? 1 : 3;
+}
+var turnedX = (x, y, k) => k === 0 ? x : k === 1 ? y : k === 2 ? -x : -y;
+var turnedY = (x, y, k) => k === 0 ? y : k === 1 ? -x : k === 2 ? -y : x;
+var EPS5 = 1e-7;
+var sign = (v) => v > EPS5 ? 1 : v < -EPS5 ? -1 : 0;
+function minTurns(p, h, t, arrive) {
+  const dx = p.x - t.x;
+  const dy = p.y - t.y;
+  if (arrive === null) {
+    const sx2 = sign(turnedX(dx, dy, h));
+    if (sign(turnedY(dx, dy, h)) === 0) return sx2 <= 0 ? 0 : 3;
+    return sx2 <= 0 ? 1 : 2;
+  }
+  const heading = (h - arrive + 4) % 4;
+  const sx = sign(turnedX(dx, dy, arrive));
+  const sy = sign(turnedY(dx, dy, arrive));
+  switch (heading) {
+    case 0:
+      if (sy === 0) return sx <= 0 ? 0 : 4;
+      return sx < 0 ? 2 : 4;
+    case 2:
+      return sy === 0 ? 4 : 2;
+    case 1:
+      return sy <= 0 && sx < 0 ? 1 : 3;
+    default:
+      return sy >= 0 && sx < 0 ? 1 : 3;
+  }
+}
+
+// src/avoid/stateTable.ts
+var StateTable = class {
+  g = new Float64Array(0);
+  from = new Int32Array(0);
+  costStamp = new Uint32Array(0);
+  doneStamp = new Uint32Array(0);
+  step = new Float64Array(0);
+  stepStamp = new Uint32Array(0);
+  gen = 0;
+  /** Forget every state. */
+  reset() {
+    if (this.gen >= 4294967280) {
+      this.costStamp.fill(0);
+      this.doneStamp.fill(0);
+      this.stepStamp.fill(0);
+      this.gen = 0;
+    }
+    this.gen++;
+  }
+  /** Make room for states `0` to `n - 1`, keeping what is there. */
+  ensure(n) {
+    if (n <= this.g.length) return;
+    const size = Math.max(n, this.g.length * 2, 1024);
+    const grow2 = (a, make) => {
+      const b = make(size);
+      b.set(a);
+      return b;
+    };
+    this.g = grow2(this.g, (k) => new Float64Array(k));
+    this.from = grow2(this.from, (k) => new Int32Array(k));
+    this.costStamp = grow2(this.costStamp, (k) => new Uint32Array(k));
+    this.doneStamp = grow2(this.doneStamp, (k) => new Uint32Array(k));
+    this.step = grow2(this.step, (k) => new Float64Array(k));
+    this.stepStamp = grow2(this.stepStamp, (k) => new Uint32Array(k));
+  }
+  cost(s) {
+    return this.costStamp[s] === this.gen ? this.g[s] : Infinity;
+  }
+  /** The state `s` was reached from, or -1 for a start. */
+  parent(s) {
+    return this.from[s];
+  }
+  reach(s, cost, parent) {
+    this.g[s] = cost;
+    this.from[s] = parent;
+    this.costStamp[s] = this.gen;
+  }
+  done(s) {
+    return this.doneStamp[s] === this.gen;
+  }
+  settle(s) {
+    this.doneStamp[s] = this.gen;
+  }
+  /** The cost remembered for step `key`, or NaN. */
+  stepCost(key) {
+    return this.stepStamp[key] === this.gen ? this.step[key] : NaN;
+  }
+  rememberStep(key, cost) {
+    this.step[key] = cost;
+    this.stepStamp[key] = this.gen;
+  }
+};
+
+// src/avoid/visibility.ts
+var EPS6 = 1e-7;
+var STRIP = 64;
+function strips(boxes, horizontal) {
+  const n = boxes.length;
+  const s = {
+    lo: new Float64Array(n),
+    hi: new Float64Array(n),
+    aLo: new Float64Array(n),
+    aHi: new Float64Array(n),
+    start: Infinity,
+    size: STRIP,
+    cells: []
+  };
+  boxes.forEach((b, i) => {
+    s.lo[i] = horizontal ? b.y : b.x;
+    s.hi[i] = horizontal ? b.y + b.height : b.x + b.width;
+    s.aLo[i] = horizontal ? b.x : b.y;
+    s.aHi[i] = horizontal ? b.x + b.width : b.y + b.height;
+    s.start = Math.min(s.start, s.lo[i]);
+  });
+  for (let i = 0; i < n; i++) {
+    for (let k = Math.floor((s.lo[i] - s.start) / STRIP); k <= Math.floor((s.hi[i] - s.start) / STRIP); k++) {
+      (s.cells[k] ??= []).push(i);
+    }
+  }
+  return s;
+}
+function reach(at, c, s, lo, hi) {
+  const cell = s.cells[Math.floor((c - s.start) / STRIP)] ?? [];
+  for (const i of cell) {
+    if (c <= s.lo[i] + EPS6 || c >= s.hi[i] - EPS6) continue;
+    if (s.aHi[i] <= at + EPS6) lo = Math.max(lo, s.aHi[i]);
+    else if (s.aLo[i] >= at - EPS6) hi = Math.min(hi, s.aLo[i]);
+    else return null;
+  }
+  return { c, lo, hi };
+}
+function merged(runs) {
+  runs.sort((a, b) => a.c - b.c || a.lo - b.lo);
+  const out = [];
+  for (const r of runs) {
+    const last = out[out.length - 1];
+    if (last !== void 0 && last.c === r.c && r.lo <= last.hi + EPS6) last.hi = Math.max(last.hi, r.hi);
+    else out.push({ ...r });
+  }
+  return out;
+}
+function after(runs, c, orAt) {
+  let lo = 0;
+  let hi = runs.length;
+  while (lo < hi) {
+    const mid = lo + hi >> 1;
+    const m = runs[mid].c;
+    if (orAt ? m < c - EPS6 : m <= c + EPS6) lo = mid + 1;
+    else hi = mid;
+  }
+  return lo;
+}
+var covers = (r, at) => r.lo <= at + EPS6 && r.hi >= at - EPS6;
+function runAt(runs, c, at) {
+  for (let k = after(runs, c, true); k < runs.length && runs[k].c <= c + EPS6; k++) if (covers(runs[k], at)) return k;
+  return -1;
+}
+function crossing(along2, from, step, across2) {
+  if (step > 0) {
+    for (let k = after(across2, from, false); k < across2.length && across2[k].c <= along2.hi + EPS6; k++) {
+      if (covers(across2[k], along2.c)) return k;
+    }
+  } else {
+    for (let k = after(across2, from, true) - 1; k >= 0 && across2[k].c >= along2.lo - EPS6; k--) {
+      if (covers(across2[k], along2.c)) return k;
+    }
+  }
+  return -1;
+}
+function castLines(points, boxes, window) {
+  const across2 = strips(boxes, true);
+  const down = strips(boxes, false);
+  const rows = [];
+  const cols = [];
+  for (const p of points) {
+    const h = reach(p.x, p.y, across2, window.x, window.x + window.width);
+    const v = h === null ? null : reach(p.y, p.x, down, window.y, window.y + window.height);
+    if (h === null || v === null) continue;
+    rows.push(h);
+    cols.push(v);
+  }
+  return { hs: merged(rows), vs: merged(cols) };
+}
+function visibilityGraph(points, boxes, window) {
+  const { hs, vs } = castLines(points, boxes, window);
+  const [x0, x1, y0, y1] = [window.x, window.x + window.width, window.y, window.y + window.height];
+  const toEdge = (r, lo, hi) => r.lo <= lo + EPS6 || r.hi >= hi - EPS6;
+  const row = [];
+  const col = [];
+  const near = [];
+  const ids = /* @__PURE__ */ new Map();
+  const idOf = (h, v) => {
+    const key = h * vs.length + v;
+    let id = ids.get(key);
+    if (id === void 0) {
+      id = row.length;
+      ids.set(key, id);
+      row.push(h);
+      col.push(v);
+      near.push(-2, -2, -2, -2);
+    }
+    return id;
+  };
+  return {
+    x: (v) => vs[col[v]].c,
+    y: (v) => hs[row[v]].c,
+    neighbor(v, d) {
+      const known = near[v * 4 + d];
+      if (known !== -2) return known;
+      const h = row[v];
+      const c = col[v];
+      let found = -1;
+      if (d === 0 || d === 2) {
+        const k = crossing(hs[h], vs[c].c, d === 0 ? 1 : -1, vs);
+        if (k >= 0) found = idOf(h, k);
+      } else {
+        const k = crossing(vs[c], hs[h].c, d === 1 ? 1 : -1, hs);
+        if (k >= 0) found = idOf(k, c);
+      }
+      near[v * 4 + d] = found;
+      return found;
+    },
+    at(p) {
+      const h = runAt(hs, p.y, p.x);
+      const v = runAt(vs, p.x, p.y);
+      return h < 0 || v < 0 ? -1 : idOf(h, v);
+    },
+    size: () => row.length,
+    open: (v) => toEdge(hs[row[v]], x0, x1) || toEdge(vs[col[v]], y0, y1)
+  };
+}
+
+// src/avoid/search.ts
+var ENCLOSED = "enclosed";
+function sealed(graph, starts) {
+  const seen = new Set(starts);
+  const queue = [...starts];
+  while (queue.length > 0) {
+    const v = queue.pop();
+    if (graph.open(v)) return false;
+    for (let d = 0; d < 4; d++) {
+      const w = graph.neighbor(v, d);
+      if (w >= 0 && !seen.has(w)) {
+        seen.add(w);
+        queue.push(w);
+      }
+    }
+  }
+  return true;
+}
+var MAX_SETTLED = 5e4;
+var TABLE = new StateTable();
+function searchLeg(sources, targets, ctx) {
+  const { bendPenalty } = ctx;
+  const ends = [...sources.map((s) => s.point), ...targets.map((t) => t.point)];
+  const boxes = ctx.obstacles.near(ctx.window);
+  const graph = visibilityGraph(interestingPoints(ctx.window, boxes, ends), boxes, ctx.window);
+  const goals = /* @__PURE__ */ new Map();
+  targets.forEach((t, k) => {
+    const v = graph.at(t.point);
+    if (v >= 0) goals.set(v, [...goals.get(v) ?? [], k]);
+  });
+  if (goals.size === 0) return ENCLOSED;
+  const h = (v, d) => {
+    const p = { x: graph.x(v), y: graph.y(v) };
+    let best = Infinity;
+    for (const t of targets) {
+      const est = Math.abs(t.point.x - p.x) + Math.abs(t.point.y - p.y) + bendPenalty * minTurns(p, d, t.point, t.arrive);
+      if (est < best) best = est;
+    }
+    return best;
+  };
+  const table = TABLE;
+  table.reset();
+  const origin = /* @__PURE__ */ new Map();
+  const heap = new MinHeap();
+  sources.forEach((s, k) => {
+    const v = graph.at(s.point);
+    const state = v * 4 + s.heading;
+    if (v < 0) return;
+    table.ensure(graph.size() * 4);
+    if (table.cost(state) <= 0) return;
+    table.reach(state, 0, -1);
+    origin.set(state, k);
+    heap.push(state, h(v, s.heading), 0);
+  });
+  const starts = [...origin.keys()].map((s) => s >> 2);
+  if (starts.length === 0) return ENCLOSED;
+  const stepCost = (v, w, key) => {
+    let cost = table.stepCost(key);
+    if (!Number.isNaN(cost)) return cost;
+    const x0 = graph.x(v);
+    const y0 = graph.y(v);
+    const x1 = graph.x(w);
+    const y1 = graph.y(w);
+    cost = Math.abs(x1 - x0) + Math.abs(y1 - y0) + (ctx.crossings ? ctx.crossings.penalty * ctx.crossings.index.crossings(ctx.edge, x0, y0, x1, y1) : 0);
+    table.rememberStep(key, cost);
+    return cost;
+  };
+  let settled = 0;
+  while (heap.size > 0) {
+    if (settled >= MAX_SETTLED) return ENCLOSED;
+    const state = heap.pop();
+    if (table.done(state)) continue;
+    table.settle(state);
+    settled++;
+    const v = state >> 2;
+    const d = state & 3;
+    const hit = goals.get(v)?.find((k) => targets[k].arrive === null || targets[k].arrive === d);
+    if (hit !== void 0) return finish(state, hit);
+    const base = table.cost(state);
+    for (let nd = 0; nd < 4; nd = nd + 1) {
+      if (nd === (d + 2 & 3)) continue;
+      const w = graph.neighbor(v, nd);
+      if (w < 0) continue;
+      table.ensure(graph.size() * 4);
+      const cost = base + stepCost(v, w, v * 4 + nd) + (nd === d ? 0 : bendPenalty);
+      const to = w * 4 + nd;
+      if (cost >= table.cost(to)) continue;
+      table.reach(to, cost, state);
+      const rest = h(w, nd);
+      heap.push(to, cost + rest, rest);
+    }
+  }
+  if (sealed(graph, starts) || sealed(graph, [...goals.keys()])) return ENCLOSED;
+  return null;
+  function finish(goal, target) {
+    const states = [goal];
+    while (table.parent(states[states.length - 1]) >= 0) states.push(table.parent(states[states.length - 1]));
+    states.reverse();
+    const source = origin.get(states[0]);
+    const points = [sources[source].point];
+    for (let k = 1; k < states.length; k++) {
+      const turnsHere = k + 1 < states.length && (states[k] & 3) !== (states[k + 1] & 3);
+      if (turnsHere) points.push({ x: graph.x(states[k] >> 2), y: graph.y(states[k] >> 2) });
+    }
+    points.push(targets[target].point);
+    return { points, source, target, arrive: goal & 3, cost: table.cost(goal) };
+  }
+}
+
+// src/avoid/edgeRoute.ts
+function exitOf(port, clearance) {
+  const len = Math.hypot(port.normal.x, port.normal.y) || 1;
+  const k = (clearance + 1) / len;
+  return { x: port.point.x + port.normal.x * k, y: port.point.y + port.normal.y * k };
+}
+var reversed = (v) => ({ x: -v.x, y: -v.y });
+function routeEdge(edge, ctx) {
+  const { clearance, bendPenalty, crossPenalty, margin } = ctx.options;
+  const fromPorts = edge.from.ports;
+  const toPorts = edge.to.ports;
+  if (fromPorts.length === 0 || toPorts.length === 0) return null;
+  const obstacles = ctx.index.forEdge(edge);
+  const waypoints = edge.waypoints ?? [];
+  const crossings = ctx.crossings === void 0 ? void 0 : { index: ctx.crossings, penalty: crossPenalty };
+  const legs = [];
+  let fromPort = null;
+  let toPort = null;
+  let heading = 0;
+  for (let k = 0; k <= waypoints.length; k++) {
+    const sources = k === 0 ? fromPorts.map((p) => ({ point: exitOf(p, clearance), heading: dirOf(p.normal) })) : [{ point: waypoints[k - 1], heading }];
+    const targets = k === waypoints.length ? toPorts.map((p) => ({ point: exitOf(p, clearance), arrive: dirOf(reversed(p.normal)) })) : [{ point: waypoints[k], arrive: null }];
+    const points = [...sources.map((s) => s.point), ...targets.map((t) => t.point)];
+    let grow2 = margin;
+    let found = null;
+    for (; ; ) {
+      const window = searchWindow(points, grow2);
+      found = searchLeg(sources, targets, { edge: edge.id, obstacles, window, bendPenalty, crossings });
+      if (found !== null || within(ctx.limit, window)) break;
+      grow2 *= 2;
+    }
+    if (found === null || found === ENCLOSED) return null;
+    if (k === 0) fromPort = fromPorts[found.source];
+    if (k === waypoints.length) toPort = toPorts[found.target];
+    heading = found.arrive;
+    legs.push(found.points);
+  }
+  legs[0] = [fromPort.point, ...legs[0]];
+  legs[legs.length - 1] = [...legs[legs.length - 1], toPort.point];
+  const out = [];
+  for (const leg of legs) {
+    const simple = simplifyStops(leg);
+    out.push(...out.length === 0 ? simple : simple.slice(1));
+  }
+  return out;
+}
+
+// src/avoid/nudge.ts
+var EPS7 = 1e-6;
+var along = (p, axis) => axis === "h" ? p.x : p.y;
+var across = (p, axis) => axis === "h" ? p.y : p.x;
+var sideOf = (v) => v > EPS7 ? 1 : v < -EPS7 ? -1 : 0;
+var isWaypoint = (p, waypoints) => waypoints.some((w) => Math.abs(w.x - p.x) < EPS7 && Math.abs(w.y - p.y) < EPS7);
+function runsOf(routes, axis) {
+  const out = [];
+  for (const [edge, { points, waypoints }] of routes) {
+    for (let i = 1; i + 2 < points.length; i++) {
+      const a = points[i];
+      const b = points[i + 1];
+      if (Math.abs(across(a, axis) - across(b, axis)) > EPS7 || Math.abs(along(a, axis) - along(b, axis)) < EPS7) continue;
+      if (isWaypoint(a, waypoints) || isWaypoint(b, waypoints)) continue;
+      const c = across(a, axis);
+      const forward = along(a, axis) < along(b, axis);
+      const [loEnd, loNext, hiEnd, hiNext] = forward ? [a, points[i - 1], b, points[i + 2]] : [b, points[i + 2], a, points[i - 1]];
+      out.push({
+        edge,
+        i,
+        c,
+        lo: along(loEnd, axis),
+        hi: along(hiEnd, axis),
+        sideLo: sideOf(across(loNext, axis) - c),
+        sideHi: sideOf(across(hiNext, axis) - c)
+      });
+    }
+  }
+  return out;
+}
+function bundlesOf(runs) {
+  runs.sort((s, t) => s.c - t.c || s.lo - t.lo);
+  const out = [];
+  let current = [];
+  let reach2 = -Infinity;
+  const flush = () => {
+    if (new Set(current.map((r) => r.edge)).size > 1) out.push(current);
+    current = [];
+  };
+  for (const run of runs) {
+    const joins = current.length > 0 && Math.abs(run.c - current[0].c) < EPS7 && run.lo < reach2 - EPS7;
+    if (!joins) {
+      flush();
+      reach2 = -Infinity;
+    }
+    current.push(run);
+    reach2 = Math.max(reach2, run.hi);
+  }
+  flush();
+  return out;
+}
+function order(s, t) {
+  if (s.sideLo !== 0 && t.sideLo !== 0 && (s.sideLo !== t.sideLo || Math.abs(s.lo - t.lo) > EPS7)) {
+    if (s.sideLo !== t.sideLo) return s.sideLo - t.sideLo;
+    return (s.lo < t.lo ? 1 : -1) * -s.sideLo;
+  }
+  if (s.sideHi !== 0 && t.sideHi !== 0 && (s.sideHi !== t.sideHi || Math.abs(s.hi - t.hi) > EPS7)) {
+    if (s.sideHi !== t.sideHi) return s.sideHi - t.sideHi;
+    return (s.hi > t.hi ? 1 : -1) * -s.sideHi;
+  }
+  return s.edge < t.edge ? -1 : s.edge > t.edge ? 1 : s.i - t.i;
+}
+function freeSpan(obstacles, axis, c, lo, hi, reach2, edges) {
+  const probe = axis === "h" ? { x: lo, y: c - reach2, width: hi - lo, height: 2 * reach2 } : { x: c - reach2, y: lo, width: 2 * reach2, height: hi - lo };
+  let low = c - reach2;
+  let high = c + reach2;
+  for (const { obstacle } of obstacles.near(probe)) {
+    if (obstacle.kind === "label" && edges.has(obstacle.edge)) continue;
+    const b = obstacle.box;
+    const [bLo, bHi, bAcross, bSize] = axis === "h" ? [b.x, b.x + b.width, b.y, b.height] : [b.y, b.y + b.height, b.x, b.width];
+    if (bHi <= lo + EPS7 || bLo >= hi - EPS7) continue;
+    if (bAcross + bSize <= c + EPS7) low = Math.max(low, bAcross + bSize);
+    else if (bAcross >= c - EPS7) high = Math.min(high, bAcross);
+  }
+  return [low + 1, high - 1];
+}
+function spread(bundle, spacing, span) {
+  const n = bundle.length;
+  const c = bundle[0].c;
+  const room = span[1] - span[0];
+  if (room <= 0) return bundle.map(() => c);
+  const step = Math.min(spacing, room / (n - 1));
+  let at = bundle.map((_, k) => c + (k - (n - 1) / 2) * step);
+  const shift = at[0] < span[0] ? span[0] - at[0] : at[n - 1] > span[1] ? span[1] - at[n - 1] : 0;
+  if (shift !== 0) at = at.map((v) => v + shift);
+  return at;
+}
+function nudgeAxis(routes, axis, spacing, obstacles) {
+  for (const bundle of bundlesOf(runsOf(routes, axis))) {
+    bundle.sort(order);
+    const lo = Math.min(...bundle.map((r) => r.lo));
+    const hi = Math.max(...bundle.map((r) => r.hi));
+    const span = freeSpan(obstacles, axis, bundle[0].c, lo, hi, spacing * bundle.length, new Set(bundle.map((r) => r.edge)));
+    spread(bundle, spacing, span).forEach((value, k) => {
+      const run = bundle[k];
+      const points = routes.get(run.edge).points;
+      for (const j of [run.i, run.i + 1]) {
+        points[j] = axis === "h" ? { x: points[j].x, y: value } : { x: value, y: points[j].y };
+      }
+    });
+  }
+}
+function simplifyKeeping(points, waypoints) {
+  const out = [];
+  let start = 0;
+  for (let k = 1; k < points.length; k++) {
+    if (k !== points.length - 1 && !isWaypoint(points[k], waypoints)) continue;
+    const piece = simplifyStops(points.slice(start, k + 1));
+    out.push(...out.length === 0 ? piece : piece.slice(1));
+    start = k;
+  }
+  return out;
+}
+function nudge(routes, spacing, obstacles) {
+  const work = new Map([...routes].map(([id, r]) => [id, { points: [...r.points], waypoints: r.waypoints }]));
+  nudgeAxis(work, "h", spacing, obstacles);
+  nudgeAxis(work, "v", spacing, obstacles);
+  return new Map([...work].map(([id, r]) => [id, simplifyKeeping(r.points, r.waypoints)]));
+}
+
+// src/avoid/router.ts
+var now = () => globalThis.performance?.now() ?? Date.now();
+function limitOf(input, margin) {
+  let x0 = Infinity;
+  let y0 = Infinity;
+  let x1 = -Infinity;
+  let y1 = -Infinity;
+  const take = (x, y) => {
+    x0 = Math.min(x0, x);
+    y0 = Math.min(y0, y);
+    x1 = Math.max(x1, x);
+    y1 = Math.max(y1, y);
+  };
+  for (const { box } of input.obstacles) {
+    take(box.x, box.y);
+    take(box.x + box.width, box.y + box.height);
+  }
+  for (const e of input.edges) {
+    for (const p of [...e.from.ports, ...e.to.ports]) take(p.point.x, p.point.y);
+    for (const w of e.waypoints ?? []) take(w.x, w.y);
+  }
+  if (x0 === Infinity) return { x: 0, y: 0, width: 0, height: 0 };
+  return { x: x0 - 2 * margin, y: y0 - 2 * margin, width: x1 - x0 + 4 * margin, height: y1 - y0 + 4 * margin };
+}
+function createAvoidRouter(options = {}) {
+  const opts = { ...AVOID_DEFAULTS, ...options };
+  let committed = /* @__PURE__ */ new Map();
+  const keys = /* @__PURE__ */ new Map();
+  const raw = /* @__PURE__ */ new Map();
+  const shown = /* @__PURE__ */ new Map();
+  const previews = /* @__PURE__ */ new Map();
+  let drag = null;
+  let positions = /* @__PURE__ */ new Map();
+  const routeOf = (edge) => {
+    const mine = shown.get(edge.id);
+    return mine !== void 0 && edge.route !== void 0 && samePoints(mine.slice(1, -1), edge.route) ? mine : fullRoute(edge);
+  };
+  const rawOf = (edge) => {
+    const mine = shown.get(edge.id);
+    return mine !== void 0 && raw.has(edge.id) && edge.route !== void 0 && samePoints(mine.slice(1, -1), edge.route) ? raw.get(edge.id) : routeOf(edge);
+  };
+  function forget(input) {
+    const live = new Set(input.edges.map((e) => e.id));
+    for (const map of [keys, raw, shown]) for (const id of [...map.keys()]) if (!live.has(id)) map.delete(id);
+  }
+  function indexForDrag(input) {
+    const routes = new Map(input.edges.map((e) => [e.id, routeOf(e)]));
+    drag = new DragIndex(input, routes, opts.clearance, limitOf(input, opts.margin));
+    positions = new Map(input.edges.map((e, k) => [e.id, k]));
+  }
+  const edgeIn = (edges, id) => {
+    const at = positions.get(id);
+    return at !== void 0 && edges[at]?.id === id ? edges[at] : edges.find((e) => e.id === id);
+  };
+  function preview(input, budgetMs) {
+    const start = now();
+    if (drag === null) indexForDrag({ obstacles: [...committed.values()], edges: input.edges });
+    const frame = drag.frame(input.obstacles);
+    const out = /* @__PURE__ */ new Map();
+    for (const id of frame.dirty) {
+      if (now() - start > budgetMs) {
+        const last = previews.get(id);
+        if (last !== void 0) out.set(id, last);
+        continue;
+      }
+      const edge = edgeIn(input.edges, id);
+      if (edge === void 0) continue;
+      const full = routeEdge(edge, { index: frame.index, options: opts, limit: frame.limit });
+      const route = full === null ? null : full.slice(1, -1);
+      previews.set(id, route);
+      out.set(id, route);
+    }
+    return out;
+  }
+  function commit(input, dirty, obstacles) {
+    previews.clear();
+    const index = new ObstacleIndex(obstacles, opts.clearance, opts.labelClearance);
+    const limit = limitOf(input, opts.margin);
+    const dirtyIds = new Set(dirty.map((e) => e.id));
+    const crossings = new SegmentIndex();
+    const clean = new SegmentIndex();
+    for (const e of input.edges) {
+      if (dirtyIds.has(e.id)) continue;
+      crossings.add(e.id, routeOf(e));
+      clean.add(e.id, rawOf(e));
+    }
+    const fresh = routeDirty(dirty, { index, options: opts, limit, crossings });
+    for (const edge of dirty) keys.set(edge.id, stopsKey(edge));
+    const byId = new Map(input.edges.map((e) => [e.id, e]));
+    const bundle = bundleOf(fresh, input.edges, clean, rawOf);
+    const nudged = nudge(bundle, opts.spacing, index);
+    const out = /* @__PURE__ */ new Map();
+    for (const [id, full] of fresh) if (full === null) {
+      raw.delete(id);
+      shown.delete(id);
+      out.set(id, null);
+    }
+    for (const [id, full] of nudged) {
+      const was = dirtyIds.has(id) ? null : routeOf(byId.get(id));
+      raw.set(id, bundle.get(id).points);
+      shown.set(id, full);
+      if (was === null || !samePoints(was, full)) out.set(id, full.slice(1, -1));
+    }
+    const edges = input.edges.map((e) => withRoute(e, out));
+    const settled = [...input.obstacles, ...labelObstacles(edges, routeOf)];
+    committed = new Map(settled.map((o) => [o.id, o]));
+    indexForDrag({ obstacles: settled, edges });
+    return out;
+  }
+  return {
+    seed(input) {
+      const obstacles = [...input.obstacles, ...labelObstacles(input.edges, fullRoute)];
+      committed = new Map(obstacles.map((o) => [o.id, o]));
+      keys.clear();
+      raw.clear();
+      shown.clear();
+      for (const e of input.edges) keys.set(e.id, stopsKey(e));
+      previews.clear();
+      indexForDrag({ obstacles, edges: input.edges });
+    },
+    update(input, updateOpts = {}) {
+      if (updateOpts.preview === true) return preview(input, updateOpts.budgetMs ?? Infinity);
+      const obstacles = [...input.obstacles, ...labelObstacles(input.edges, routeOf)];
+      const changed = changedObstacles(committed, obstacles);
+      const dirty = dirtyEdges(input.edges, keys, changed, opts.clearance, routeOf);
+      forget(input);
+      return commit(input, dirty, obstacles);
+    }
+  };
+}
+function routeDirty(dirty, ctx) {
+  const fresh = /* @__PURE__ */ new Map();
+  for (const edge of dirty) {
+    const full = routeEdge(edge, ctx);
+    fresh.set(edge.id, full);
+    if (full !== null) ctx.crossings.add(edge.id, full);
+    if (edge.label === void 0) continue;
+    const label = labelObstacle(edge, full ?? fullRoute(edge));
+    if (label === null) ctx.index.delete(edge.label.id);
+    else ctx.index.replace(label);
+  }
+  return fresh;
+}
+function bundleOf(fresh, edges, clean, rawOf) {
+  const bundle = /* @__PURE__ */ new Map();
+  const mates = /* @__PURE__ */ new Set();
+  const waypoints = new Map(edges.map((e) => [e.id, e.waypoints ?? []]));
+  for (const [id, full] of fresh) {
+    if (full === null) continue;
+    bundle.set(id, { points: full, waypoints: waypoints.get(id) });
+    for (let i = 1; i + 2 < full.length; i++) clean.edgesMeeting(segmentBox(full[i], full[i + 1]), mates);
+  }
+  for (const e of edges) {
+    if (mates.has(e.id) && !fresh.has(e.id)) bundle.set(e.id, { points: rawOf(e), waypoints: e.waypoints ?? [] });
+  }
+  return bundle;
+}
+function withRoute(edge, routes) {
+  const route = routes.get(edge.id);
+  if (route === void 0) return edge;
+  const { route: _r, ...rest } = edge;
+  return route === null ? rest : { ...rest, route };
+}
+var segmentBox = (a, b) => ({
+  x: Math.min(a.x, b.x),
+  y: Math.min(a.y, b.y),
+  width: Math.abs(a.x - b.x),
+  height: Math.abs(a.y - b.y)
+});
+
+// src/hops/crossings.ts
+var EPS8 = 1e-9;
+var round = (v) => Math.round(v * 1e3) / 1e3;
+var boxOf2 = (a, b) => ({
+  x: Math.min(a.x, b.x),
+  y: Math.min(a.y, b.y),
+  width: Math.abs(b.x - a.x),
+  height: Math.abs(b.y - a.y)
+});
+function properCrossing(p, q) {
+  const rx = p.b.x - p.a.x;
+  const ry = p.b.y - p.a.y;
+  const sx = q.b.x - q.a.x;
+  const sy = q.b.y - q.a.y;
+  const den = rx * sy - ry * sx;
+  if (Math.abs(den) <= EPS8 * Math.hypot(rx, ry) * Math.hypot(sx, sy)) return null;
+  const qx = q.a.x - p.a.x;
+  const qy = q.a.y - p.a.y;
+  const t = (qx * sy - qy * sx) / den;
+  const u = (qx * ry - qy * rx) / den;
+  return t > EPS8 && t < 1 - EPS8 && u > EPS8 && u < 1 - EPS8 ? t : null;
+}
+var far = (p, ends, d) => ends.every((e) => Math.hypot(p.x - e.x, p.y - e.y) >= d);
+function mergeAlong(seg, found, r) {
+  found.sort((m, n) => m.t - n.t);
+  const len = Math.hypot(seg.b.x - seg.a.x, seg.b.y - seg.a.y);
+  const out = [];
+  let run = null;
+  const flush = () => {
+    if (run === null) return;
+    const mid = (run.from + run.to) / 2 / len;
+    out.push({
+      at: { x: round(seg.a.x + (seg.b.x - seg.a.x) * mid), y: round(seg.a.y + (seg.b.y - seg.a.y) * mid) },
+      over: run.over,
+      r: round((run.to - run.from) / 2 + r)
+    });
+  };
+  for (const c of found) {
+    if (run !== null && c.t - run.to < 2 * r) {
+      run.to = c.t;
+      if (!run.over.includes(c.over)) run.over.push(c.over);
+      continue;
+    }
+    flush();
+    run = { from: c.t, to: c.t, over: [c.over] };
+  }
+  flush();
+  return out;
+}
+function edgeHops(polylines, order2, r, only) {
+  const hash = new SpatialHash();
+  const segments = /* @__PURE__ */ new Map();
+  order2.forEach((edge, rank) => {
+    const points = polylines.get(edge);
+    if (points === void 0) return;
+    const list = [];
+    for (let i = 1; i < points.length; i++) {
+      const seg = { edge, rank, a: points[i - 1], b: points[i] };
+      if (seg.a.x === seg.b.x && seg.a.y === seg.b.y) continue;
+      list.push(seg);
+      hash.insert(seg, boxOf2(seg.a, seg.b));
+    }
+    segments.set(edge, list);
+  });
+  const endsOf = (edge) => {
+    const p = polylines.get(edge);
+    return [p[0], p[p.length - 1]];
+  };
+  const out = /* @__PURE__ */ new Map();
+  const near = [];
+  for (const edge of order2) {
+    if (only !== void 0 && !only.has(edge)) continue;
+    const hops = [];
+    const ends = segments.has(edge) ? endsOf(edge) : [];
+    for (const seg of segments.get(edge) ?? []) {
+      const len = Math.hypot(seg.b.x - seg.a.x, seg.b.y - seg.a.y);
+      const found = [];
+      near.length = 0;
+      for (const other of hash.query(boxOf2(seg.a, seg.b), near)) {
+        if (other.rank >= seg.rank) continue;
+        const f = properCrossing(seg, other);
+        if (f === null) continue;
+        const t = f * len;
+        const at = { x: seg.a.x + (seg.b.x - seg.a.x) * f, y: seg.a.y + (seg.b.y - seg.a.y) * f };
+        if (t < r || len - t < r || !far(at, ends, 2 * r) || !far(at, endsOf(other.edge), 2 * r)) continue;
+        found.push({ t, over: other.edge });
+      }
+      if (found.length > 0) hops.push(...mergeAlong(seg, found, r));
+    }
+    out.set(edge, hops);
+  }
+  return out;
+}
+var NAMED = { start: 0, mid: 0.5, end: 1 };
+var grow = (b, by) => ({ x: b.x - by, y: b.y - by, width: b.width + 2 * by, height: b.height + 2 * by });
+function overlapArea(a, b) {
+  const w = Math.min(a.x + a.width, b.x + b.width) - Math.max(a.x, b.x);
+  const h = Math.min(a.y + a.height, b.y + b.height) - Math.max(a.y, b.y);
+  return w > 0 && h > 0 ? w * h : 0;
+}
+function crossesBox(a, b, box) {
+  let t0 = 0;
+  let t1 = 1;
+  const dx = b.x - a.x;
+  const dy = b.y - a.y;
+  const clip = (p, q) => {
+    if (p === 0) return q > 0;
+    const r = q / p;
+    if (p < 0) t0 = Math.max(t0, r);
+    else t1 = Math.min(t1, r);
+    return t0 < t1;
+  };
+  return clip(-dx, a.x - box.x) && clip(dx, box.x + box.width - a.x) && clip(-dy, a.y - box.y) && clip(dy, box.y + box.height - a.y);
+}
+function arcNearest(points, p) {
+  let best = Infinity;
+  let at = 0;
+  let walked = 0;
+  for (let i = 0; i + 1 < points.length; i++) {
+    const a = points[i];
+    const b = points[i + 1];
+    const dx = b.x - a.x;
+    const dy = b.y - a.y;
+    const len = Math.hypot(dx, dy);
+    const t = len === 0 ? 0 : Math.max(0, Math.min(1, ((p.x - a.x) * dx + (p.y - a.y) * dy) / (len * len)));
+    const d = Math.hypot(a.x + t * dx - p.x, a.y + t * dy - p.y);
+    if (d < best) {
+      best = d;
+      at = walked + t * len;
+    }
+    walked += len;
+  }
+  return at;
+}
+function candidatesOf(label, route, tries, spacing) {
+  const { at, offset = 0 } = label.placement;
+  const out = [{ placement: { at, offset }, spot: null }];
+  const length = route.length;
+  if (length === 0) return out;
+  const start = typeof at === "object" ? arcNearest(route.points, at.near) : (typeof at === "number" ? at : NAMED[at] ?? 0.5) * length;
+  const sides = offset === 0 ? [0] : [offset, -offset];
+  const push = (s, side) => {
+    const spot = { at: s / length, offset: side };
+    out.push({ placement: { at: spot.at, offset: side }, spot });
+  };
+  if (offset !== 0) push(start, -offset);
+  const step = label.size.width + spacing;
+  for (let k = 1; k <= tries; k++) {
+    for (const dir of [1, -1]) {
+      const s = start + dir * k * step;
+      if (s < 0 || s > length) continue;
+      for (const side of sides) push(s, side);
+    }
+  }
+  return out;
+}
+var boxAround = (c, size) => ({ x: c.x - size.width / 2, y: c.y - size.height / 2, width: size.width, height: size.height });
+function costOf(box, edge, field) {
+  const probe = grow(box, field.gap);
+  let cost = 0;
+  for (const s of field.shapes.query(probe)) cost += 1e3 * overlapArea(probe, s);
+  for (const l of field.labels.query(probe)) cost += 100 * overlapArea(probe, l);
+  const covered = /* @__PURE__ */ new Set();
+  for (const s of field.segments.query(probe)) if (s.edge !== edge && crossesBox(s.a, s.b, probe)) covered.add(s.edge);
+  return cost + 10 * covered.size;
+}
+function settle(label, route, field, tries, spacing) {
+  let best = null;
+  let home = null;
+  for (const c of candidatesOf(label, route, tries, spacing)) {
+    const center = labelCenter(route.path, c.placement, label.size);
+    if (center === null) continue;
+    home ??= center;
+    const box = boxAround(center, label.size);
+    const score = costOf(box, label.edge, field) + Math.hypot(center.x - home.x, center.y - home.y);
+    if (best === null || score < best.score) best = { spot: c.spot, box, score };
+    if (score === 0) break;
+  }
+  return best;
+}
+function fileSegments(field, edge, run) {
+  for (let i = 0; i + 1 < run.length; i++) {
+    const a = run[i];
+    const b = run[i + 1];
+    field.segments.insert({ edge, a, b }, { x: Math.min(a.x, b.x), y: Math.min(a.y, b.y), width: Math.abs(a.x - b.x), height: Math.abs(a.y - b.y) });
+  }
+}
+function placeLabels(input, opts = {}) {
+  const tries = opts.tries ?? 4;
+  const spacing = opts.spacing ?? 8;
+  const field = { shapes: new SpatialHash(), labels: new SpatialHash(), segments: new SpatialHash(), gap: opts.gap ?? 2 };
+  for (const { box } of input.shapes) field.shapes.insert(box, box);
+  const routes = /* @__PURE__ */ new Map();
+  for (const { id, points, more = [] } of input.routes) {
+    for (const run of [points, ...more]) fileSegments(field, id, run);
+    if (points.length < 2) continue;
+    let length = 0;
+    for (let i = 0; i + 1 < points.length; i++) length += Math.hypot(points[i + 1].x - points[i].x, points[i + 1].y - points[i].y);
+    routes.set(id, { path: polylineFromPoints(points), points, length });
+  }
+  const moving = [];
+  for (const label of input.labels) {
+    const route = routes.get(label.edge);
+    if (route === void 0) continue;
+    if (label.moving !== false && label.placement.dodge !== false) {
+      moving.push(label);
+      continue;
+    }
+    const center = labelCenter(route.path, label.placement, label.size);
+    if (center === null) continue;
+    const box = boxAround(center, label.size);
+    field.labels.insert(box, box);
+  }
+  moving.sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
+  const out = /* @__PURE__ */ new Map();
+  for (const label of moving) {
+    const best = settle(label, routes.get(label.edge), field, tries, spacing);
+    if (best === null) continue;
+    out.set(label.id, best.spot);
+    field.labels.insert(best.box, best.box);
+  }
+  return out;
+}
+
+export { AVOID_DEFAULTS, DEFAULT_HOP_SIZE, HOPS_DOC_KEY, createAvoidRouter, edgeHops, placeLabels, simplifyStops };
+//# sourceMappingURL=chunk-T6DQT553.js.map
+//# sourceMappingURL=chunk-T6DQT553.js.map