@multiplatform.one/node-graph 9.0.1 → 9.0.2

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