@multiplatform.one/node-graph 9.0.1 → 9.0.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -173,66 +173,69 @@ function samplePath(d) {
173
173
  points.push(at);
174
174
  command = "L";
175
175
  } else if (command === "L") {
176
- var to = {
176
+ at = sampleLine(points, at, {
177
177
  x: take(),
178
178
  y: take()
179
- };
180
- var steps = Math.max(1, Math.ceil(Math.hypot(to.x - at.x, to.y - at.y) / 4));
181
- for (var step = 1; step <= steps; step += 1) {
182
- var t = step / steps;
183
- points.push({
184
- x: at.x + (to.x - at.x) * t,
185
- y: at.y + (to.y - at.y) * t
186
- });
187
- }
188
- at = to;
179
+ });
189
180
  } else if (command === "Q") {
190
- var control = {
181
+ at = sampleQuadratic(points, at, {
191
182
  x: take(),
192
183
  y: take()
193
- };
194
- var to1 = {
184
+ }, {
195
185
  x: take(),
196
186
  y: take()
197
- };
198
- for (var step1 = 1; step1 <= 8; step1 += 1) {
199
- var t1 = step1 / 8;
200
- var u = 1 - t1;
201
- points.push({
202
- x: u * u * at.x + 2 * u * t1 * control.x + t1 * t1 * to1.x,
203
- y: u * u * at.y + 2 * u * t1 * control.y + t1 * t1 * to1.y
204
- });
205
- }
206
- at = to1;
187
+ });
207
188
  } else if (command === "C") {
208
- var first = {
189
+ at = sampleCubic(points, at, {
209
190
  x: take(),
210
191
  y: take()
211
- };
212
- var second = {
192
+ }, {
213
193
  x: take(),
214
194
  y: take()
215
- };
216
- var to2 = {
195
+ }, {
217
196
  x: take(),
218
197
  y: take()
219
- };
220
- var steps1 = Math.max(16, Math.ceil(Math.hypot(to2.x - at.x, to2.y - at.y) / 4));
221
- for (var step2 = 1; step2 <= steps1; step2 += 1) {
222
- var t2 = step2 / steps1;
223
- var u1 = 1 - t2;
224
- points.push({
225
- x: u1 * u1 * u1 * at.x + 3 * u1 * u1 * t2 * first.x + 3 * u1 * t2 * t2 * second.x + t2 * t2 * t2 * to2.x,
226
- y: u1 * u1 * u1 * at.y + 3 * u1 * u1 * t2 * first.y + 3 * u1 * t2 * t2 * second.y + t2 * t2 * t2 * to2.y
227
- });
228
- }
229
- at = to2;
198
+ });
230
199
  } else {
231
200
  return points;
232
201
  }
233
202
  }
234
203
  return points;
235
204
  }
205
+ function sampleLine(points, at, to) {
206
+ var steps = Math.max(1, Math.ceil(Math.hypot(to.x - at.x, to.y - at.y) / 4));
207
+ for (var step = 1; step <= steps; step += 1) {
208
+ var t = step / steps;
209
+ points.push({
210
+ x: at.x + (to.x - at.x) * t,
211
+ y: at.y + (to.y - at.y) * t
212
+ });
213
+ }
214
+ return to;
215
+ }
216
+ function sampleQuadratic(points, at, control, to) {
217
+ for (var step = 1; step <= 8; step += 1) {
218
+ var t = step / 8;
219
+ var u = 1 - t;
220
+ points.push({
221
+ x: u * u * at.x + 2 * u * t * control.x + t * t * to.x,
222
+ y: u * u * at.y + 2 * u * t * control.y + t * t * to.y
223
+ });
224
+ }
225
+ return to;
226
+ }
227
+ function sampleCubic(points, at, first, second, to) {
228
+ var steps = Math.max(16, Math.ceil(Math.hypot(to.x - at.x, to.y - at.y) / 4));
229
+ for (var step = 1; step <= steps; step += 1) {
230
+ var t = step / steps;
231
+ var u = 1 - t;
232
+ points.push({
233
+ x: u * u * u * at.x + 3 * u * u * t * first.x + 3 * u * t * t * second.x + t * t * t * to.x,
234
+ y: u * u * u * at.y + 3 * u * u * t * first.y + 3 * u * t * t * second.y + t * t * t * to.y
235
+ });
236
+ }
237
+ return to;
238
+ }
236
239
  function distanceToBox(point, box) {
237
240
  var dx = Math.max(box.x - point.x, 0, point.x - (box.x + box.width));
238
241
  var dy = Math.max(box.y - point.y, 0, point.y - (box.y + box.height));
@@ -478,6 +481,30 @@ function directionIndex(side) {
478
481
  });
479
482
  }
480
483
  function orthogonalRoute(start, startDirection, goal, goalDirection, boxes, clearance, area) {
484
+ var grid = routeGrid(start, goal, boxes, clearance, area);
485
+ var startX = gridIndex(grid.xs, start.x);
486
+ var startY = gridIndex(grid.ys, start.y);
487
+ var goalX = gridIndex(grid.xs, goal.x);
488
+ var goalY = gridIndex(grid.ys, goal.y);
489
+ if (startX < 0 || startY < 0 || goalX < 0 || goalY < 0) return null;
490
+ if (!gridFree(grid, startX, startY) || !gridFree(grid, goalX, goalY)) return null;
491
+ var search = {
492
+ grid,
493
+ goal,
494
+ goalX,
495
+ goalY,
496
+ goalDirection,
497
+ turn: clearance * 4,
498
+ best: /* @__PURE__ */new Map(),
499
+ from: /* @__PURE__ */new Map(),
500
+ heap: new Heap()
501
+ };
502
+ var first = gridKey(grid, startX, startY, startDirection);
503
+ var reached = searchRoute(search, first, startX, startY);
504
+ if (reached === void 0) return null;
505
+ return traceRoute(grid, search.from, reached);
506
+ }
507
+ function routeGrid(start, goal, boxes, clearance, area) {
481
508
  var rects = boxes.map(function (box) {
482
509
  return inflate(box, clearance);
483
510
  });
@@ -487,86 +514,123 @@ function orthogonalRoute(start, startDirection, goal, goalDirection, boxes, clea
487
514
  var ys = lines([start.y, goal.y, area.y, area.y + area.height, ...rects.flatMap(function (r) {
488
515
  return [r.top, r.bottom];
489
516
  })]);
490
- var columns = xs.length;
491
- var rows = ys.length;
492
- var startX = xs.indexOf(Math.round(start.x * 1e3) / 1e3);
493
- var startY = ys.indexOf(Math.round(start.y * 1e3) / 1e3);
494
- var goalX = xs.indexOf(Math.round(goal.x * 1e3) / 1e3);
495
- var goalY = ys.indexOf(Math.round(goal.y * 1e3) / 1e3);
496
- if (startX < 0 || startY < 0 || goalX < 0 || goalY < 0) return null;
497
- var free = function free2(ix2, iy2) {
498
- return rects.every(function (rect) {
499
- return !strictlyInside(xs[ix2], ys[iy2], rect);
500
- });
501
- };
502
- var open = function open2(ax, ay, bx, by) {
503
- var minX = Math.min(xs[ax], xs[bx]);
504
- var maxX = Math.max(xs[ax], xs[bx]);
505
- var minY = Math.min(ys[ay], ys[by]);
506
- var maxY = Math.max(ys[ay], ys[by]);
507
- return rects.every(function (rect) {
508
- if (minY === maxY) return !(minY > rect.top && minY < rect.bottom && maxX > rect.left && minX < rect.right);
509
- return !(minX > rect.left && minX < rect.right && maxY > rect.top && minY < rect.bottom);
510
- });
511
- };
512
- if (!free(startX, startY) || !free(goalX, goalY)) return null;
513
- var turn = clearance * 4;
514
- var key = function key2(ix2, iy2, dir2) {
515
- return (iy2 * columns + ix2) * 4 + dir2;
517
+ return {
518
+ xs,
519
+ ys,
520
+ rects
516
521
  };
517
- var best = /* @__PURE__ */new Map();
518
- var from = /* @__PURE__ */new Map();
519
- var heap = new Heap();
520
- var heuristic = function heuristic2(ix2, iy2) {
521
- return Math.abs(xs[ix2] - goal.x) + Math.abs(ys[iy2] - goal.y);
522
+ }
523
+ function gridIndex(values, value) {
524
+ return values.indexOf(Math.round(value * 1e3) / 1e3);
525
+ }
526
+ function gridFree(grid, ix, iy) {
527
+ return grid.rects.every(function (rect) {
528
+ return !strictlyInside(grid.xs[ix], grid.ys[iy], rect);
529
+ });
530
+ }
531
+ function gridOpen(grid, ax, ay, bx, by) {
532
+ var {
533
+ xs,
534
+ ys
535
+ } = grid;
536
+ var minX = Math.min(xs[ax], xs[bx]);
537
+ var maxX = Math.max(xs[ax], xs[bx]);
538
+ var minY = Math.min(ys[ay], ys[by]);
539
+ var maxY = Math.max(ys[ay], ys[by]);
540
+ return grid.rects.every(function (rect) {
541
+ if (minY === maxY) return !(minY > rect.top && minY < rect.bottom && maxX > rect.left && minX < rect.right);
542
+ return !(minX > rect.left && minX < rect.right && maxY > rect.top && minY < rect.bottom);
543
+ });
544
+ }
545
+ function canStep(grid, ix, iy, nx, ny) {
546
+ if (nx < 0 || ny < 0 || nx >= grid.xs.length || ny >= grid.ys.length) return false;
547
+ return gridFree(grid, nx, ny) && gridOpen(grid, ix, iy, nx, ny);
548
+ }
549
+ function gridKey(grid, ix, iy, dir) {
550
+ return (iy * grid.xs.length + ix) * 4 + dir;
551
+ }
552
+ function gridCell(grid, key) {
553
+ var columns = grid.xs.length;
554
+ var dir = key % 4;
555
+ var cell = (key - dir) / 4;
556
+ var ix = cell % columns;
557
+ return {
558
+ ix,
559
+ iy: (cell - ix) / columns,
560
+ dir
522
561
  };
523
- var first = key(startX, startY, startDirection);
562
+ }
563
+ function routeHeuristic(search, ix, iy) {
564
+ return Math.abs(search.grid.xs[ix] - search.goal.x) + Math.abs(search.grid.ys[iy] - search.goal.y);
565
+ }
566
+ function bendCost(search, dir, next, nx, ny) {
567
+ var atGoal = nx === search.goalX && ny === search.goalY;
568
+ return (next === dir ? 0 : search.turn) + (atGoal && next !== search.goalDirection ? search.turn : 0);
569
+ }
570
+ function searchRoute(search, first, startX, startY) {
571
+ var {
572
+ best,
573
+ heap
574
+ } = search;
524
575
  best.set(first, 0);
525
- heap.push(first, heuristic(startX, startY));
526
- var reached;
576
+ heap.push(first, routeHeuristic(search, startX, startY));
527
577
  var budget = 2e5;
528
578
  while (heap.size > 0 && budget > 0) {
529
579
  var _best_get;
530
580
  budget -= 1;
531
581
  var current = heap.pop();
532
582
  if (!current) break;
533
- var dir = current.key % 4;
534
- var cell = (current.key - dir) / 4;
535
- var ix = cell % columns;
536
- var iy = (cell - ix) / columns;
583
+ var {
584
+ ix,
585
+ iy,
586
+ dir
587
+ } = gridCell(search.grid, current.key);
537
588
  var cost = (_best_get = best.get(current.key)) !== null && _best_get !== void 0 ? _best_get : Infinity;
538
- if (current.cost - heuristic(ix, iy) > cost + 1e-6) continue;
539
- if (ix === goalX && iy === goalY) {
540
- reached = current.key;
541
- break;
542
- }
543
- for (var next = 0; next < 4; next += 1) {
544
- var _best_get1;
545
- if (next === (dir + 2) % 4) continue;
546
- var nx = ix + stepX[next];
547
- var ny = iy + stepY[next];
548
- if (nx < 0 || ny < 0 || nx >= columns || ny >= rows) continue;
549
- if (!free(nx, ny) || !open(ix, iy, nx, ny)) continue;
550
- var atGoal = nx === goalX && ny === goalY;
551
- var length = Math.abs(xs[nx] - xs[ix]) + Math.abs(ys[ny] - ys[iy]);
552
- var bend = (next === dir ? 0 : turn) + (atGoal && next !== goalDirection ? turn : 0);
553
- var nextKey = key(nx, ny, next);
554
- var nextCost = cost + length + bend;
555
- if (nextCost < ((_best_get1 = best.get(nextKey)) !== null && _best_get1 !== void 0 ? _best_get1 : Infinity)) {
556
- best.set(nextKey, nextCost);
557
- from.set(nextKey, current.key);
558
- heap.push(nextKey, nextCost + heuristic(nx, ny));
559
- }
589
+ if (current.cost - routeHeuristic(search, ix, iy) > cost + 1e-6) continue;
590
+ if (ix === search.goalX && iy === search.goalY) return current.key;
591
+ relaxNeighbours(search, {
592
+ key: current.key,
593
+ ix,
594
+ iy,
595
+ dir,
596
+ cost
597
+ });
598
+ }
599
+ return void 0;
600
+ }
601
+ function relaxNeighbours(search, node) {
602
+ var {
603
+ grid,
604
+ best,
605
+ from,
606
+ heap
607
+ } = search;
608
+ for (var next = 0; next < 4; next += 1) {
609
+ var _best_get;
610
+ if (next === (node.dir + 2) % 4) continue;
611
+ var nx = node.ix + stepX[next];
612
+ var ny = node.iy + stepY[next];
613
+ if (!canStep(grid, node.ix, node.iy, nx, ny)) continue;
614
+ var length = Math.abs(grid.xs[nx] - grid.xs[node.ix]) + Math.abs(grid.ys[ny] - grid.ys[node.iy]);
615
+ var nextKey = gridKey(grid, nx, ny, next);
616
+ var nextCost = node.cost + length + bendCost(search, node.dir, next, nx, ny);
617
+ if (nextCost < ((_best_get = best.get(nextKey)) !== null && _best_get !== void 0 ? _best_get : Infinity)) {
618
+ best.set(nextKey, nextCost);
619
+ from.set(nextKey, node.key);
620
+ heap.push(nextKey, nextCost + routeHeuristic(search, nx, ny));
560
621
  }
561
622
  }
562
- if (reached === void 0) return null;
623
+ }
624
+ function traceRoute(grid, from, reached) {
563
625
  var route = [];
564
626
  for (var at = reached; at !== void 0; at = from.get(at)) {
565
- var cell1 = (at - at % 4) / 4;
566
- var ix1 = cell1 % columns;
627
+ var {
628
+ ix,
629
+ iy
630
+ } = gridCell(grid, at);
567
631
  route.push({
568
- x: xs[ix1],
569
- y: ys[(cell1 - ix1) / columns]
632
+ x: grid.xs[ix],
633
+ y: grid.ys[iy]
570
634
  });
571
635
  }
572
636
  return route.reverse();
@@ -963,7 +1027,7 @@ function virtualPoint(open, ideal, goal) {
963
1027
  function linkKey(link) {
964
1028
  return `${link.source}\0${link.target}`;
965
1029
  }
966
- function planTracks(links, boxes, side, clearance, sharing) {
1030
+ function layersOf(boxes, side, clearance) {
967
1031
  var frame = frames[side];
968
1032
  var spans = new Map(boxes.map(function (box) {
969
1033
  return [box.id, localSpan(box, frame)];
@@ -971,101 +1035,146 @@ function planTracks(links, boxes, side, clearance, sharing) {
971
1035
  var ranks = ranksOf([...spans.values()]);
972
1036
  var rankOf = /* @__PURE__ */new Map();
973
1037
  ranks.forEach(function (rank, index) {
974
- var _iteratorNormalCompletion5 = true,
975
- _didIteratorError5 = false,
976
- _iteratorError5 = void 0;
1038
+ var _iteratorNormalCompletion = true,
1039
+ _didIteratorError = false,
1040
+ _iteratorError = void 0;
977
1041
  try {
978
- for (var _iterator5 = rank.spans[Symbol.iterator](), _step5; !(_iteratorNormalCompletion5 = (_step5 = _iterator5.next()).done); _iteratorNormalCompletion5 = true) {
979
- var span = _step5.value;
1042
+ for (var _iterator = rank.spans[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
1043
+ var span = _step.value;
980
1044
  rankOf.set(span, index);
981
1045
  }
982
1046
  } catch (err) {
983
- _didIteratorError5 = true;
984
- _iteratorError5 = err;
1047
+ _didIteratorError = true;
1048
+ _iteratorError = err;
985
1049
  } finally {
986
1050
  try {
987
- if (!_iteratorNormalCompletion5 && _iterator5.return != null) {
988
- _iterator5.return();
1051
+ if (!_iteratorNormalCompletion && _iterator.return != null) {
1052
+ _iterator.return();
989
1053
  }
990
1054
  } finally {
991
- if (_didIteratorError5) {
992
- throw _iteratorError5;
1055
+ if (_didIteratorError) {
1056
+ throw _iteratorError;
993
1057
  }
994
1058
  }
995
1059
  }
996
1060
  });
997
- var open = ranks.map(function (rank) {
998
- return channels(rank, clearance);
1061
+ return {
1062
+ spans,
1063
+ ranks,
1064
+ rankOf,
1065
+ open: ranks.map(function (rank) {
1066
+ return channels(rank, clearance);
1067
+ })
1068
+ };
1069
+ }
1070
+ function forwardEnds(link, layers) {
1071
+ var source = layers.spans.get(link.source);
1072
+ var target = layers.spans.get(link.target);
1073
+ if (!source || !target) return void 0;
1074
+ var rs = layers.rankOf.get(source);
1075
+ var rt = layers.rankOf.get(target);
1076
+ if (rt <= rs) return void 0;
1077
+ return {
1078
+ source,
1079
+ target,
1080
+ rs,
1081
+ rt
1082
+ };
1083
+ }
1084
+ function virtualCourse(id, param, open) {
1085
+ var {
1086
+ source,
1087
+ target,
1088
+ rs,
1089
+ rt
1090
+ } = param;
1091
+ var sourceU = (source.u0 + source.u1) / 2;
1092
+ var targetU = (target.u0 + target.u1) / 2;
1093
+ var us = [sourceU];
1094
+ var passes = [];
1095
+ for (var rank = rs + 1; rank < rt; rank += 1) {
1096
+ var ideal = sourceU + (targetU - sourceU) * (rank - rs) / (rt - rs);
1097
+ var at = virtualPoint(open[rank], ideal, targetU);
1098
+ us.push(at.u);
1099
+ passes.push({
1100
+ link: id,
1101
+ rank,
1102
+ slot: us.length - 1,
1103
+ ...at
1104
+ });
1105
+ }
1106
+ us.push(targetU);
1107
+ return {
1108
+ us,
1109
+ passes
1110
+ };
1111
+ }
1112
+ function groupsAt(gaps, gap) {
1113
+ var groups = gaps.get(gap);
1114
+ if (!groups) {
1115
+ groups = /* @__PURE__ */new Map();
1116
+ gaps.set(gap, groups);
1117
+ }
1118
+ return groups;
1119
+ }
1120
+ function widenGroup(groups, key, lone, a, b) {
1121
+ var group = groups.get(key);
1122
+ if (group) {
1123
+ group.u0 = Math.min(group.u0, a, b);
1124
+ group.u1 = Math.max(group.u1, a, b);
1125
+ } else groups.set(key, {
1126
+ key,
1127
+ lone,
1128
+ u0: Math.min(a, b),
1129
+ u1: Math.max(a, b)
999
1130
  });
1000
- var gaps = /* @__PURE__ */new Map();
1001
- var pieces = /* @__PURE__ */new Map();
1002
- var passing = [];
1003
- var virtual = /* @__PURE__ */new Map();
1004
- var channelOf = /* @__PURE__ */new Map();
1131
+ }
1132
+ function placePieces(gaps, link, id, us, param, sharing) {
1133
+ var {
1134
+ rs,
1135
+ rt
1136
+ } = param;
1137
+ var own = [];
1138
+ for (var gap = rs; gap < rt; gap += 1) {
1139
+ var last = gap === rt - 1;
1140
+ var key = last ? trackKey(sharing, link) : `${id}\0${gap}`;
1141
+ own.push({
1142
+ gap,
1143
+ key
1144
+ });
1145
+ widenGroup(groupsAt(gaps, gap), key, rt - rs === 1, us[gap - rs], us[gap - rs + 1]);
1146
+ }
1147
+ return own;
1148
+ }
1149
+ function collectPieces(links, layers, sharing) {
1150
+ var plan = {
1151
+ gaps: /* @__PURE__ */new Map(),
1152
+ pieces: /* @__PURE__ */new Map(),
1153
+ passing: [],
1154
+ virtual: /* @__PURE__ */new Map(),
1155
+ channelOf: /* @__PURE__ */new Map()
1156
+ };
1005
1157
  var _iteratorNormalCompletion = true,
1006
1158
  _didIteratorError = false,
1007
1159
  _iteratorError = void 0;
1008
1160
  try {
1009
- var _loop = function () {
1161
+ for (var _iterator = links[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
1010
1162
  var link = _step.value;
1011
- var source = spans.get(link.source);
1012
- var target = spans.get(link.target);
1013
- if (!source || !target) return "continue";
1014
- var rs = rankOf.get(source);
1015
- var rt = rankOf.get(target);
1016
- if (rt <= rs) return "continue";
1017
- var id2 = linkKey(link);
1018
- if (pieces.has(id2)) return "continue";
1019
- var sourceU = (source.u0 + source.u1) / 2;
1020
- var targetU = (target.u0 + target.u1) / 2;
1021
- var us = [sourceU];
1022
- for (var rank = rs + 1; rank < rt; rank += 1) {
1023
- var ideal = sourceU + (targetU - sourceU) * (rank - rs) / (rt - rs);
1024
- var at = virtualPoint(open[rank], ideal, targetU);
1025
- us.push(at.u);
1026
- passing.push({
1027
- link: id2,
1028
- rank,
1029
- slot: us.length - 1,
1030
- ...at
1031
- });
1032
- }
1033
- us.push(targetU);
1034
- virtual.set(id2, us);
1035
- channelOf.set(id2, passing.filter(function (pass2) {
1036
- return pass2.link === id2;
1037
- }).map(function (pass2) {
1038
- return open[pass2.rank][pass2.channel];
1163
+ var ends = forwardEnds(link, layers);
1164
+ if (!ends) continue;
1165
+ var id = linkKey(link);
1166
+ if (plan.pieces.has(id)) continue;
1167
+ var {
1168
+ us,
1169
+ passes
1170
+ } = virtualCourse(id, ends, layers.open);
1171
+ plan.passing.push(...passes);
1172
+ plan.virtual.set(id, us);
1173
+ plan.channelOf.set(id, passes.map(function (pass) {
1174
+ return layers.open[pass.rank][pass.channel];
1039
1175
  }));
1040
- var own2 = [];
1041
- for (var gap = rs; gap < rt; gap += 1) {
1042
- var last = gap === rt - 1;
1043
- var key2 = last ? trackKey(sharing, link) : `${id2}\0${gap}`;
1044
- own2.push({
1045
- gap,
1046
- key: key2
1047
- });
1048
- var groups = gaps.get(gap);
1049
- if (!groups) {
1050
- groups = /* @__PURE__ */new Map();
1051
- gaps.set(gap, groups);
1052
- }
1053
- var a = us[gap - rs];
1054
- var b = us[gap - rs + 1];
1055
- var group = groups.get(key2);
1056
- if (group) {
1057
- group.u0 = Math.min(group.u0, a, b);
1058
- group.u1 = Math.max(group.u1, a, b);
1059
- } else groups.set(key2, {
1060
- key: key2,
1061
- lone: rt - rs === 1,
1062
- u0: Math.min(a, b),
1063
- u1: Math.max(a, b)
1064
- });
1065
- }
1066
- pieces.set(id2, own2);
1067
- };
1068
- for (var _iterator = links[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) _loop();
1176
+ plan.pieces.set(id, placePieces(plan.gaps, link, id, us, ends, sharing));
1177
+ }
1069
1178
  } catch (err) {
1070
1179
  _didIteratorError = true;
1071
1180
  _iteratorError = err;
@@ -1080,17 +1189,59 @@ function planTracks(links, boxes, side, clearance, sharing) {
1080
1189
  }
1081
1190
  }
1082
1191
  }
1192
+ return plan;
1193
+ }
1194
+ function spreadChannel(group, open, virtual, clearance) {
1195
+ if (group.length < 2) return;
1196
+ var [lo, hi] = open[group[0].rank][group[0].channel];
1197
+ var sorted = [...group].sort(function (a, b) {
1198
+ return a.u - b.u || a.link.localeCompare(b.link);
1199
+ });
1200
+ var crowded = sorted.some(function (pass, index) {
1201
+ return index > 0 && pass.u - sorted[index - 1].u < clearance;
1202
+ });
1203
+ if (!crowded) return;
1204
+ var width = Number.isFinite(lo) && Number.isFinite(hi) ? hi - lo : clearance * (group.length + 1);
1205
+ var base = Number.isFinite(lo) ? lo : Number.isFinite(hi) ? hi - width : sorted[0].u;
1206
+ var pitch = width / (group.length + 1);
1207
+ sorted.forEach(function (pass, index) {
1208
+ virtual.get(pass.link)[pass.slot] = base + pitch * (index + 1);
1209
+ });
1210
+ }
1211
+ function spreadChannels(passing, open, virtual, clearance) {
1083
1212
  var byChannel = /* @__PURE__ */new Map();
1084
- var _iteratorNormalCompletion1 = true,
1085
- _didIteratorError1 = false,
1086
- _iteratorError1 = void 0;
1213
+ var _iteratorNormalCompletion = true,
1214
+ _didIteratorError = false,
1215
+ _iteratorError = void 0;
1087
1216
  try {
1088
- for (var _iterator1 = passing[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true) {
1089
- var pass = _step1.value;
1217
+ for (var _iterator = passing[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
1218
+ var pass = _step.value;
1090
1219
  var _byChannel_get;
1091
1220
  var key = `${pass.rank}:${pass.channel}`;
1092
1221
  byChannel.set(key, [...((_byChannel_get = byChannel.get(key)) !== null && _byChannel_get !== void 0 ? _byChannel_get : []), pass]);
1093
1222
  }
1223
+ } catch (err) {
1224
+ _didIteratorError = true;
1225
+ _iteratorError = err;
1226
+ } finally {
1227
+ try {
1228
+ if (!_iteratorNormalCompletion && _iterator.return != null) {
1229
+ _iterator.return();
1230
+ }
1231
+ } finally {
1232
+ if (_didIteratorError) {
1233
+ throw _iteratorError;
1234
+ }
1235
+ }
1236
+ }
1237
+ var _iteratorNormalCompletion1 = true,
1238
+ _didIteratorError1 = false,
1239
+ _iteratorError1 = void 0;
1240
+ try {
1241
+ for (var _iterator1 = byChannel.values()[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true) {
1242
+ var group = _step1.value;
1243
+ spreadChannel(group, open, virtual, clearance);
1244
+ }
1094
1245
  } catch (err) {
1095
1246
  _didIteratorError1 = true;
1096
1247
  _iteratorError1 = err;
@@ -1105,207 +1256,195 @@ function planTracks(links, boxes, side, clearance, sharing) {
1105
1256
  }
1106
1257
  }
1107
1258
  }
1108
- var _iteratorNormalCompletion2 = true,
1109
- _didIteratorError2 = false,
1110
- _iteratorError2 = void 0;
1259
+ }
1260
+ function conflictSets(list, clearance) {
1261
+ var parent = list.map(function (_, index2) {
1262
+ return index2;
1263
+ });
1264
+ var root = function root2(index2) {
1265
+ var at2 = index2;
1266
+ while (parent[at2] !== at2) at2 = parent[at2];
1267
+ return at2;
1268
+ };
1269
+ for (var a = 0; a < list.length; a += 1) for (var b = a + 1; b < list.length; b += 1) if (list[a].u0 <= list[b].u1 + clearance && list[b].u0 <= list[a].u1 + clearance) parent[root(b)] = root(a);
1270
+ var sets = /* @__PURE__ */new Map();
1271
+ for (var index = 0; index < list.length; index += 1) {
1272
+ var _sets_get;
1273
+ var at = root(index);
1274
+ sets.set(at, [...((_sets_get = sets.get(at)) !== null && _sets_get !== void 0 ? _sets_get : []), list[index]]);
1275
+ }
1276
+ return [...sets.values()];
1277
+ }
1278
+ function lanesOf(members, clearance) {
1279
+ var sorted = [...members].sort(function (a, b) {
1280
+ return a.u0 - b.u0 || a.key.localeCompare(b.key);
1281
+ });
1282
+ var ends = [];
1283
+ var lane = /* @__PURE__ */new Map();
1284
+ var _iteratorNormalCompletion = true,
1285
+ _didIteratorError = false,
1286
+ _iteratorError = void 0;
1111
1287
  try {
1112
- var _loop1 = function () {
1113
- var group = _step2.value;
1114
- if (group.length < 2) return "continue";
1115
- var [lo, hi] = open[group[0].rank][group[0].channel];
1116
- var sorted = [...group].sort(function (a, b) {
1117
- return a.u - b.u || a.link.localeCompare(b.link);
1118
- });
1119
- var crowded = sorted.some(function (pass2, index) {
1120
- return index > 0 && pass2.u - sorted[index - 1].u < clearance;
1121
- });
1122
- if (!crowded) return "continue";
1123
- var width = Number.isFinite(lo) && Number.isFinite(hi) ? hi - lo : clearance * (group.length + 1);
1124
- var base = Number.isFinite(lo) ? lo : Number.isFinite(hi) ? hi - width : sorted[0].u;
1125
- var pitch = width / (group.length + 1);
1126
- sorted.forEach(function (pass2, index) {
1127
- virtual.get(pass2.link)[pass2.slot] = base + pitch * (index + 1);
1288
+ var _loop = function () {
1289
+ var group = _step.value;
1290
+ var free = ends.findIndex(function (end) {
1291
+ return end + clearance < group.u0;
1128
1292
  });
1293
+ if (free < 0) {
1294
+ free = ends.length;
1295
+ ends.push(group.u1);
1296
+ } else ends[free] = group.u1;
1297
+ lane.set(group.key, free);
1129
1298
  };
1130
- for (var _iterator2 = byChannel.values()[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) _loop1();
1299
+ for (var _iterator = sorted[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) _loop();
1131
1300
  } catch (err) {
1132
- _didIteratorError2 = true;
1133
- _iteratorError2 = err;
1301
+ _didIteratorError = true;
1302
+ _iteratorError = err;
1134
1303
  } finally {
1135
1304
  try {
1136
- if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
1137
- _iterator2.return();
1305
+ if (!_iteratorNormalCompletion && _iterator.return != null) {
1306
+ _iterator.return();
1138
1307
  }
1139
1308
  } finally {
1140
- if (_didIteratorError2) {
1141
- throw _iteratorError2;
1309
+ if (_didIteratorError) {
1310
+ throw _iteratorError;
1142
1311
  }
1143
1312
  }
1144
1313
  }
1145
- var levels = /* @__PURE__ */new Map();
1146
- var _iteratorNormalCompletion3 = true,
1147
- _didIteratorError3 = false,
1148
- _iteratorError3 = void 0;
1314
+ return {
1315
+ lane,
1316
+ count: ends.length
1317
+ };
1318
+ }
1319
+ function levelGap(gap, groups, ranks, clearance, levels) {
1320
+ var lo = ranks[gap].v1 + clearance;
1321
+ var hi = ranks[gap + 1].v0 - clearance;
1322
+ if (lo >= hi) return;
1323
+ var _iteratorNormalCompletion = true,
1324
+ _didIteratorError = false,
1325
+ _iteratorError = void 0;
1149
1326
  try {
1150
- var _loop2 = function () {
1151
- var [gap, groups] = _step3.value;
1152
- var lo = ranks[gap].v1 + clearance;
1153
- var hi = ranks[gap + 1].v0 - clearance;
1154
- if (lo >= hi) return "continue";
1155
- var list = [...groups.values()];
1156
- var parent = list.map(function (_, index2) {
1157
- return index2;
1158
- });
1159
- var root = function root2(index2) {
1160
- var at2 = index2;
1161
- while (parent[at2] !== at2) at2 = parent[at2];
1162
- return at2;
1163
- };
1164
- for (var a = 0; a < list.length; a += 1) for (var b = a + 1; b < list.length; b += 1) if (list[a].u0 <= list[b].u1 + clearance && list[b].u0 <= list[a].u1 + clearance) parent[root(b)] = root(a);
1165
- var sets = /* @__PURE__ */new Map();
1166
- for (var index = 0; index < list.length; index += 1) {
1167
- var _sets_get;
1168
- var at = root(index);
1169
- sets.set(at, [...((_sets_get = sets.get(at)) !== null && _sets_get !== void 0 ? _sets_get : []), list[index]]);
1170
- }
1171
- var _iteratorNormalCompletion5 = true,
1172
- _didIteratorError5 = false,
1173
- _iteratorError5 = void 0;
1327
+ for (var _iterator = conflictSets([...groups.values()], clearance)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
1328
+ var members = _step.value;
1329
+ var {
1330
+ lane,
1331
+ count
1332
+ } = lanesOf(members, clearance);
1333
+ if (count < 2 && members.every(function (group) {
1334
+ return group.lone;
1335
+ })) continue;
1336
+ var pitch = (hi - lo) / (count + 1);
1337
+ var _iteratorNormalCompletion1 = true,
1338
+ _didIteratorError1 = false,
1339
+ _iteratorError1 = void 0;
1174
1340
  try {
1175
- for (var _iterator5 = sets.values()[Symbol.iterator](), _step5; !(_iteratorNormalCompletion5 = (_step5 = _iterator5.next()).done); _iteratorNormalCompletion5 = true) {
1176
- var members = _step5.value;
1177
- var sorted = [...members].sort(function (a2, b2) {
1178
- return a2.u0 - b2.u0 || a2.key.localeCompare(b2.key);
1179
- });
1180
- var ends = [];
1181
- var lane = /* @__PURE__ */new Map();
1182
- var _iteratorNormalCompletion12 = true,
1183
- _didIteratorError12 = false,
1184
- _iteratorError12 = void 0;
1185
- try {
1186
- var _loop3 = function () {
1187
- var group = _step12.value;
1188
- var free = ends.findIndex(function (end) {
1189
- return end + clearance < group.u0;
1190
- });
1191
- if (free < 0) {
1192
- free = ends.length;
1193
- ends.push(group.u1);
1194
- } else ends[free] = group.u1;
1195
- lane.set(group.key, free);
1196
- };
1197
- for (var _iterator12 = sorted[Symbol.iterator](), _step12; !(_iteratorNormalCompletion12 = (_step12 = _iterator12.next()).done); _iteratorNormalCompletion12 = true) _loop3();
1198
- } catch (err) {
1199
- _didIteratorError12 = true;
1200
- _iteratorError12 = err;
1201
- } finally {
1202
- try {
1203
- if (!_iteratorNormalCompletion12 && _iterator12.return != null) {
1204
- _iterator12.return();
1205
- }
1206
- } finally {
1207
- if (_didIteratorError12) {
1208
- throw _iteratorError12;
1209
- }
1210
- }
1211
- }
1212
- if (ends.length < 2 && members.every(function (group) {
1213
- return group.lone;
1214
- })) continue;
1215
- var pitch = (hi - lo) / (ends.length + 1);
1216
- var _iteratorNormalCompletion22 = true,
1217
- _didIteratorError22 = false,
1218
- _iteratorError22 = void 0;
1219
- try {
1220
- for (var _iterator22 = lane[Symbol.iterator](), _step22; !(_iteratorNormalCompletion22 = (_step22 = _iterator22.next()).done); _iteratorNormalCompletion22 = true) {
1221
- var [key2, index1] = _step22.value;
1222
- levels.set(`${gap}\0${key2}`, lo + pitch * (index1 + 1));
1223
- }
1224
- } catch (err) {
1225
- _didIteratorError22 = true;
1226
- _iteratorError22 = err;
1227
- } finally {
1228
- try {
1229
- if (!_iteratorNormalCompletion22 && _iterator22.return != null) {
1230
- _iterator22.return();
1231
- }
1232
- } finally {
1233
- if (_didIteratorError22) {
1234
- throw _iteratorError22;
1235
- }
1236
- }
1237
- }
1341
+ for (var _iterator1 = lane[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true) {
1342
+ var [key, index] = _step1.value;
1343
+ levels.set(`${gap}\0${key}`, lo + pitch * (index + 1));
1238
1344
  }
1239
1345
  } catch (err) {
1240
- _didIteratorError5 = true;
1241
- _iteratorError5 = err;
1346
+ _didIteratorError1 = true;
1347
+ _iteratorError1 = err;
1242
1348
  } finally {
1243
1349
  try {
1244
- if (!_iteratorNormalCompletion5 && _iterator5.return != null) {
1245
- _iterator5.return();
1350
+ if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
1351
+ _iterator1.return();
1246
1352
  }
1247
1353
  } finally {
1248
- if (_didIteratorError5) {
1249
- throw _iteratorError5;
1354
+ if (_didIteratorError1) {
1355
+ throw _iteratorError1;
1250
1356
  }
1251
1357
  }
1252
1358
  }
1253
- };
1254
- for (var _iterator3 = gaps[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) _loop2();
1359
+ }
1360
+ } catch (err) {
1361
+ _didIteratorError = true;
1362
+ _iteratorError = err;
1363
+ } finally {
1364
+ try {
1365
+ if (!_iteratorNormalCompletion && _iterator.return != null) {
1366
+ _iterator.return();
1367
+ }
1368
+ } finally {
1369
+ if (_didIteratorError) {
1370
+ throw _iteratorError;
1371
+ }
1372
+ }
1373
+ }
1374
+ }
1375
+ function levelsOf(gaps, ranks, clearance) {
1376
+ var levels = /* @__PURE__ */new Map();
1377
+ var _iteratorNormalCompletion = true,
1378
+ _didIteratorError = false,
1379
+ _iteratorError = void 0;
1380
+ try {
1381
+ for (var _iterator = gaps[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
1382
+ var [gap, groups] = _step.value;
1383
+ levelGap(gap, groups, ranks, clearance, levels);
1384
+ }
1255
1385
  } catch (err) {
1256
- _didIteratorError3 = true;
1257
- _iteratorError3 = err;
1386
+ _didIteratorError = true;
1387
+ _iteratorError = err;
1258
1388
  } finally {
1259
1389
  try {
1260
- if (!_iteratorNormalCompletion3 && _iterator3.return != null) {
1261
- _iterator3.return();
1390
+ if (!_iteratorNormalCompletion && _iterator.return != null) {
1391
+ _iterator.return();
1262
1392
  }
1263
1393
  } finally {
1264
- if (_didIteratorError3) {
1265
- throw _iteratorError3;
1394
+ if (_didIteratorError) {
1395
+ throw _iteratorError;
1266
1396
  }
1267
1397
  }
1268
1398
  }
1399
+ return levels;
1400
+ }
1401
+ function coursesOf(plan, levels) {
1269
1402
  var courses = /* @__PURE__ */new Map();
1270
- var _iteratorNormalCompletion4 = true,
1271
- _didIteratorError4 = false,
1272
- _iteratorError4 = void 0;
1403
+ var _iteratorNormalCompletion = true,
1404
+ _didIteratorError = false,
1405
+ _iteratorError = void 0;
1273
1406
  try {
1274
- for (var _iterator4 = pieces[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) {
1275
- var [id, own] = _step4.value;
1276
- var _channelOf_get;
1407
+ for (var _iterator = plan.pieces[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
1408
+ var [id, own] = _step.value;
1409
+ var _plan_channelOf_get;
1277
1410
  var vs = own.map(function (param) {
1278
1411
  var {
1279
1412
  gap,
1280
- key: key2
1413
+ key
1281
1414
  } = param;
1282
- return levels.get(`${gap}\0${key2}`);
1415
+ return levels.get(`${gap}\0${key}`);
1283
1416
  });
1284
1417
  if (vs.some(function (v) {
1285
1418
  return v === void 0;
1286
1419
  })) continue;
1287
1420
  courses.set(id, {
1288
1421
  vs,
1289
- us: virtual.get(id).slice(1, -1),
1290
- open: (_channelOf_get = channelOf.get(id)) !== null && _channelOf_get !== void 0 ? _channelOf_get : []
1422
+ us: plan.virtual.get(id).slice(1, -1),
1423
+ open: (_plan_channelOf_get = plan.channelOf.get(id)) !== null && _plan_channelOf_get !== void 0 ? _plan_channelOf_get : []
1291
1424
  });
1292
1425
  }
1293
1426
  } catch (err) {
1294
- _didIteratorError4 = true;
1295
- _iteratorError4 = err;
1427
+ _didIteratorError = true;
1428
+ _iteratorError = err;
1296
1429
  } finally {
1297
1430
  try {
1298
- if (!_iteratorNormalCompletion4 && _iterator4.return != null) {
1299
- _iterator4.return();
1431
+ if (!_iteratorNormalCompletion && _iterator.return != null) {
1432
+ _iterator.return();
1300
1433
  }
1301
1434
  } finally {
1302
- if (_didIteratorError4) {
1303
- throw _iteratorError4;
1435
+ if (_didIteratorError) {
1436
+ throw _iteratorError;
1304
1437
  }
1305
1438
  }
1306
1439
  }
1307
1440
  return courses;
1308
1441
  }
1442
+ function planTracks(links, boxes, side, clearance, sharing) {
1443
+ var layers = layersOf(boxes, side, clearance);
1444
+ var plan = collectPieces(links, layers, sharing);
1445
+ spreadChannels(plan.passing, layers.open, plan.virtual, clearance);
1446
+ return coursesOf(plan, levelsOf(plan.gaps, layers.ranks, clearance));
1447
+ }
1309
1448
  var plans = /* @__PURE__ */new WeakMap();
1310
1449
  function tracksFor(obstacles, side) {
1311
1450
  var {