@dineug/erd-editor 4.2.0 → 5.0.0

package/dist/utils/draw-relationship/index.js

@@ -0,0 +1,198 @@
+import { arrayHas } from "../arrayHas.js";
+import { observable } from "../../r-html/dist/observable/index.js";
+import { curveReach } from "./bezier.js";
+import { loopReach } from "./loop.js";
+//#region src/utils/draw-relationship/index.ts
+var DirectionName = {
+	left: "left",
+	right: "right",
+	top: "top",
+	bottom: "bottom"
+};
+var DirectionNameList = Object.values(DirectionName);
+arrayHas([
+	DirectionName.top,
+	DirectionName.bottom,
+	DirectionName.left,
+	DirectionName.right
+]);
+var EMPTY_SLOTS = [0, 0];
+function copyAnchor({ tableId, x, y, direction }) {
+	return {
+		tableId,
+		x,
+		y,
+		direction
+	};
+}
+var createSortChannel = () => ({
+	epoch: 0,
+	stubSlots: /* @__PURE__ */ new WeakMap(),
+	routes: /* @__PURE__ */ new WeakMap(),
+	anchors: /* @__PURE__ */ new WeakMap()
+});
+var channels = {
+	document: createSortChannel(),
+	flow: createSortChannel()
+};
+var viewVersions = { flow: /* @__PURE__ */ new WeakMap() };
+function viewVersionOf(relationship, source) {
+	const versions = viewVersions[source];
+	let held = versions.get(relationship);
+	if (!held) {
+		held = observable({ version: 0 });
+		versions.set(relationship, held);
+	}
+	return held;
+}
+function observeView(relationship, source) {
+	return viewVersionOf(relationship, source).version;
+}
+var routeVersions = /* @__PURE__ */ new WeakMap();
+var heldRedraws = /* @__PURE__ */ new WeakMap();
+function observeRoute(relationship) {
+	let held = routeVersions.get(relationship);
+	if (!held) {
+		held = observable({ version: 0 });
+		routeVersions.set(relationship, held);
+	}
+	return held.version;
+}
+function bumpRoute(relationship) {
+	const held = routeVersions.get(relationship);
+	if (held) held.version += 1;
+}
+function holdRouteRedraws(state) {
+	if (!heldRedraws.has(state)) heldRedraws.set(state, /* @__PURE__ */ new Set());
+}
+function releaseRouteRedraws(state) {
+	const held = heldRedraws.get(state);
+	if (!held) return;
+	heldRedraws.delete(state);
+	for (const relationship of held) bumpRoute(relationship);
+}
+function heldRouteRedraws(state) {
+	return heldRedraws.get(state);
+}
+function bumpView(relationship, source) {
+	viewVersionOf(relationship, source).version += 1;
+}
+function clearSortChannel(relationships, source = "document") {
+	const channel = channels[source];
+	for (const relationship of relationships) {
+		const hadSlots = channel.stubSlots.delete(relationship);
+		const hadRoute = channel.routes.delete(relationship);
+		const hadAnchors = channel.anchors.delete(relationship);
+		if (source !== "document" && (hadSlots || hadRoute || hadAnchors)) bumpView(relationship, source);
+	}
+}
+var sameSlots = (a, b) => a[0] === b[0] && a[1] === b[1];
+var sameAnchor = (a, b) => a.x === b.x && a.y === b.y && a.direction === b.direction;
+var ROUTE_EPSILON = .01;
+var samePoints = (a, b) => a.length === b.length && a.every((point, index) => Math.abs(point.x - b[index].x) < ROUTE_EPSILON && Math.abs(point.y - b[index].y) < ROUTE_EPSILON);
+function setStubSlots(relationship, slots, source = "document") {
+	const channel = channels[source];
+	if (source !== "document" && !sameSlots(channel.stubSlots.get(relationship) ?? EMPTY_SLOTS, slots)) bumpView(relationship, source);
+	channel.stubSlots.set(relationship, slots);
+}
+function getStubSlots(relationship, source = "document") {
+	if (source !== "document") observeView(relationship, source);
+	return channels[source].stubSlots.get(relationship) ?? EMPTY_SLOTS;
+}
+function setRoute(relationship, points, source = "document", held) {
+	const channel = channels[source];
+	const was = channel.routes.get(relationship);
+	if (!was || !samePoints(was.points, points)) {
+		if (source !== "document") bumpView(relationship, source);
+		else if (held) held.add(relationship);
+		else bumpRoute(relationship);
+	}
+	channel.routes.set(relationship, {
+		points,
+		epoch: channel.epoch
+	});
+}
+function getRoute(relationship, source = "document") {
+	if (source === "document") observeRoute(relationship);
+	else observeView(relationship, source);
+	return channels[source].routes.get(relationship)?.points;
+}
+function nextSortEpoch(source = "document") {
+	channels[source].epoch += 1;
+}
+function getAnchors(relationship, source = "document") {
+	if (source === "document") return relationship;
+	observeView(relationship, source);
+	return channels[source].anchors.get(relationship) ?? relationship;
+}
+function setAnchors(relationship, { start, end }, source = "document") {
+	if (source === "document") {
+		relationship.start.direction = start.direction;
+		relationship.start.x = start.x;
+		relationship.start.y = start.y;
+		relationship.end.direction = end.direction;
+		relationship.end.x = end.x;
+		relationship.end.y = end.y;
+		return;
+	}
+	const { anchors } = channels[source];
+	const seen = anchors.get(relationship) ?? relationship;
+	if (!sameAnchor(seen.start, start) || !sameAnchor(seen.end, end)) bumpView(relationship, source);
+	anchors.set(relationship, {
+		start: copyAnchor(start),
+		end: copyAnchor(end)
+	});
+}
+function aabb(points) {
+	let minX = Infinity;
+	let minY = Infinity;
+	let maxX = -Infinity;
+	let maxY = -Infinity;
+	for (const { x, y } of points) {
+		if (x < minX) minX = x;
+		if (y < minY) minY = y;
+		if (x > maxX) maxX = x;
+		if (y > maxY) maxY = y;
+	}
+	return {
+		x: minX,
+		y: minY,
+		width: maxX - minX,
+		height: maxY - minY
+	};
+}
+function inflate({ x, y, width, height }, padding) {
+	return {
+		x: x - padding,
+		y: y - padding,
+		width: width + padding * 2,
+		height: height + padding * 2
+	};
+}
+function relationshipStrokeWidth(source = "document") {
+	return source === "document" ? 2 : 1;
+}
+function getRouteBBox(relationship, strokeWidth = 2, source = "document") {
+	const channel = channels[source];
+	const { start, end } = getAnchors(relationship, source);
+	const entry = channel.routes.get(relationship);
+	const routed = entry && entry.epoch === channel.epoch ? entry.points : null;
+	if (start.tableId === end.tableId) return inflate(aabb([start, end]), 21 + strokeWidth + loopReach(start, end));
+	const slack = routed ? 0 : 48;
+	if (source !== "document") {
+		const box = aabb([
+			...routed?.length ? [routed[0], routed[routed.length - 1]] : [],
+			start,
+			end
+		]);
+		const reach = curveReach(Math.max(box.width, box.height) + 2 * slack);
+		return inflate(box, 21 + strokeWidth + slack + reach);
+	}
+	return inflate(aabb(routed ? [
+		...routed,
+		start,
+		end
+	] : [start, end]), 21 + strokeWidth + slack);
+}
+//#endregion
+export { DirectionName, DirectionNameList, clearSortChannel, copyAnchor, getAnchors, getRoute, getRouteBBox, getStubSlots, heldRouteRedraws, holdRouteRedraws, nextSortEpoch, relationshipStrokeWidth, releaseRouteRedraws, setAnchors, setRoute, setStubSlots };

package/dist/utils/draw-relationship/loop.js

@@ -0,0 +1,25 @@
+import { cubicPolyline } from "./bezier.js";
+//#region src/utils/draw-relationship/loop.ts
+var LOOP_STUB_RATIO = 1.2;
+var LOOP_CURVATURE = 1.25;
+function loopOffset(start, end) {
+	return Math.max(Math.abs(end.x - start.x), Math.abs(end.y - start.y));
+}
+function loopStub(start, end) {
+	return LOOP_STUB_RATIO * loopOffset(start, end);
+}
+function loopReach(start, end) {
+	return 2.45 * loopOffset(start, end);
+}
+function loopPolyline(from, fromOutward, to, toOutward, offset) {
+	const reach = LOOP_CURVATURE * offset;
+	return cubicPolyline(from, {
+		x: from.x + fromOutward.x * reach,
+		y: from.y + fromOutward.y * reach
+	}, {
+		x: to.x + toOutward.x * reach,
+		y: to.y + toOutward.y * reach
+	}, to, 48);
+}
+//#endregion
+export { LOOP_CURVATURE, LOOP_STUB_RATIO, loopOffset, loopPolyline, loopReach, loopStub };

package/dist/utils/draw-relationship/nudge.js

@@ -0,0 +1,402 @@
+import { countBlocked, segmentHitsBox } from "./route.js";
+//#region src/utils/draw-relationship/nudge.ts
+var NUDGE_GAP = 10;
+var NUDGE_GAPS = [
+	NUDGE_GAP,
+	7,
+	4
+];
+var SEPARATED = NUDGE_GAPS[NUDGE_GAPS.length - 1] - .5;
+var MAX_LANE_DRIFT = 3;
+function collectSlots(routes) {
+	const slots = [];
+	for (const [relationshipId, points] of routes) for (let index = 0; index < points.length - 1; index++) {
+		const a = points[index];
+		const b = points[index + 1];
+		const vertical = Math.abs(a.x - b.x) < .5;
+		if (vertical === Math.abs(a.y - b.y) < .5) continue;
+		slots.push({
+			relationshipId,
+			points,
+			index,
+			movable: index > 0 && index < points.length - 2,
+			vertical,
+			coordinate: vertical ? a.x : a.y,
+			low: vertical ? Math.min(a.y, b.y) : Math.min(a.x, b.x),
+			high: vertical ? Math.max(a.y, b.y) : Math.max(a.x, b.x)
+		});
+	}
+	return slots;
+}
+function compareSlots(a, b) {
+	if (a.relationshipId !== b.relationshipId) return a.relationshipId < b.relationshipId ? -1 : 1;
+	return a.index - b.index;
+}
+function entryOf(slot) {
+	const entry = slot.points[slot.index - 1];
+	return slot.vertical ? entry.y : entry.x;
+}
+function refreshExtents(slots) {
+	for (const slot of slots) {
+		const a = slot.points[slot.index];
+		const b = slot.points[slot.index + 1];
+		slot.low = slot.vertical ? Math.min(a.y, b.y) : Math.min(a.x, b.x);
+		slot.high = slot.vertical ? Math.max(a.y, b.y) : Math.max(a.x, b.x);
+	}
+}
+function moveSlot(slot, coordinate) {
+	const a = slot.points[slot.index];
+	const b = slot.points[slot.index + 1];
+	if (slot.vertical) {
+		a.x = coordinate;
+		b.x = coordinate;
+	} else {
+		a.y = coordinate;
+		b.y = coordinate;
+	}
+}
+function nudgeRoutes(routes, obstacles, endpoints, memo) {
+	const vertical = [];
+	const horizontal = [];
+	for (const slot of collectSlots(routes)) (slot.vertical ? vertical : horizontal).push(slot);
+	for (const axis of [vertical, horizontal]) {
+		refreshExtents(axis);
+		const slots = axis.filter((slot) => slot.movable);
+		if (!slots.length) continue;
+		const fixed = axis.filter((slot) => !slot.movable).sort((a, b) => a.coordinate - b.coordinate);
+		slots.sort((a, b) => a.coordinate - b.coordinate || compareSlots(a, b));
+		let channel = [];
+		const flush = () => {
+			if (channel.length > 1) separateRuns(channel, axis, fixed, obstacles, endpoints, memo);
+			else if (channel.length) separate(channel, axis, fixed, obstacles, endpoints, memo);
+			channel = [];
+		};
+		for (const slot of slots) {
+			const previous = channel[channel.length - 1];
+			if (previous && slot.coordinate - previous.coordinate > 10.5) flush();
+			channel.push(slot);
+		}
+		flush();
+	}
+}
+function separateRuns(channel, axis, fixed, obstacles, endpoints, memo) {
+	channel.sort((a, b) => a.low - b.low || compareSlots(a, b));
+	let group = [];
+	let reach = -Infinity;
+	const flush = () => {
+		for (const run of closeRuns(group)) separate(run, axis, fixed, obstacles, endpoints, memo);
+		group = [];
+		reach = -Infinity;
+	};
+	for (const slot of channel) {
+		if (group.length && slot.low >= reach) flush();
+		group.push(slot);
+		reach = Math.max(reach, slot.high);
+	}
+	flush();
+}
+function closeRuns(group) {
+	if (group.length < 2) return group.length ? [group] : [];
+	const root = group.map((_, index) => index);
+	const find = (index) => {
+		while (root[index] !== index) {
+			root[index] = root[root[index]];
+			index = root[index];
+		}
+		return index;
+	};
+	for (let i = 0; i < group.length; i++) {
+		const a = group[i];
+		for (let j = i + 1; j < group.length; j++) {
+			const b = group[j];
+			if (Math.abs(a.coordinate - b.coordinate) > 10.5) continue;
+			if (a.low >= b.high || b.low >= a.high) continue;
+			root[find(j)] = find(i);
+		}
+	}
+	const runs = /* @__PURE__ */ new Map();
+	group.forEach((slot, index) => {
+		const key = find(index);
+		const run = runs.get(key);
+		if (run) run.push(slot);
+		else runs.set(key, [slot]);
+	});
+	return [...runs.values()];
+}
+function crowdsLane(a, b) {
+	return a.high + NUDGE_GAP > b.low && b.high + NUDGE_GAP > a.low;
+}
+function overlapLength(a, b) {
+	if (Math.abs(a.coordinate - b.coordinate) >= SEPARATED) return 0;
+	return Math.max(0, Math.min(a.high, b.high) - Math.max(a.low, b.low));
+}
+function stillOverlapping(group, neighbours) {
+	let total = 0;
+	for (let i = 0; i < group.length; i++) {
+		const a = group[i];
+		for (let j = i + 1; j < group.length; j++) total += overlapLength(a, group[j]);
+		for (const other of neighbours) total += overlapLength(a, other);
+	}
+	return total;
+}
+function neighboursOf(group, axis) {
+	const members = new Set(group);
+	let low = Infinity;
+	let high = -Infinity;
+	for (const slot of group) {
+		if (slot.coordinate < low) low = slot.coordinate;
+		if (slot.coordinate > high) high = slot.coordinate;
+	}
+	const reach = (group.length > 1 ? NUDGE_GAP * (group.length - 1) / 2 : NUDGE_GAP) + SEPARATED;
+	const neighbours = [];
+	for (const slot of axis) {
+		if (slot.coordinate < low - reach || slot.coordinate > high + reach) continue;
+		if (members.has(slot)) continue;
+		neighbours.push(slot);
+	}
+	return neighbours;
+}
+function colourGroup(group) {
+	const tracks = [];
+	for (const slot of group) {
+		const track = tracks.find((members) => !crowdsLane(members[members.length - 1], slot));
+		if (track) track.push(slot);
+		else tracks.push([slot]);
+	}
+	return tracks;
+}
+function separate(group, axis, fixed, obstacles, endpoints, memo) {
+	if (!memo) {
+		separateGroup(group, axis, fixed, obstacles, endpoints);
+		return;
+	}
+	if (replay(group, memo)) return;
+	const before = group.map((slot) => slot.coordinate);
+	const drawn = group.map((slot, index) => memo.coordinate(slot.relationshipId, slot.index, slot.vertical) ?? before[index]);
+	separateGroup(group, axis, fixed, obstacles, endpoints);
+	markMoved(group, before, memo);
+	markMoved(group, drawn, memo);
+}
+function overlapsFixed(slot, fixed) {
+	let low = 0;
+	let high = fixed.length;
+	while (low < high) {
+		const middle = low + high >> 1;
+		if (fixed[middle].coordinate <= slot.coordinate - SEPARATED) low = middle + 1;
+		else high = middle;
+	}
+	for (let index = low; index < fixed.length; index++) {
+		if (fixed[index].coordinate >= slot.coordinate + SEPARATED) break;
+		if (overlapLength(slot, fixed[index]) > 0) return true;
+	}
+	return false;
+}
+function separateGroup(group, axis, fixed, obstacles, endpoints) {
+	if (group.length === 1 && !overlapsFixed(group[0], fixed)) return;
+	const neighbours = neighboursOf(group, axis);
+	const before = stillOverlapping(group, neighbours);
+	if (!before) return;
+	if (group.length === 1) {
+		separateLone(group[0], neighbours, before, obstacles, endpoints);
+		return;
+	}
+	const baselines = /* @__PURE__ */ new Map();
+	const originals = group.map((slot) => {
+		baselines.set(slot, baselineOf(slot, obstacles, endpoints));
+		return slot.coordinate;
+	});
+	const centre = originals.reduce((total, value) => total + value, 0) / originals.length;
+	const candidates = laneModels(group);
+	let best = null;
+	let bestLeft = Infinity;
+	for (const gap of NUDGE_GAPS) {
+		let cleared = null;
+		let clearedDrift = Infinity;
+		for (const tracks of candidates) {
+			place(tracks, gap, centre, baselines, obstacles, endpoints);
+			const left = stillOverlapping(group, neighbours);
+			if (!left) {
+				const drift = totalDrift(group, originals);
+				if (drift < clearedDrift) {
+					clearedDrift = drift;
+					cleared = group.map((slot) => slot.coordinate);
+				}
+			} else if (left < bestLeft) {
+				best = group.map((slot) => slot.coordinate);
+				bestLeft = left;
+			}
+			apply(group, originals);
+		}
+		if (cleared) {
+			apply(group, cleared);
+			return;
+		}
+	}
+	if (best && bestLeft < before) apply(group, best);
+}
+function separateLone(slot, neighbours, before, obstacles, endpoints) {
+	const baseline = baselineOf(slot, obstacles, endpoints);
+	const origin = slot.coordinate;
+	let best = origin;
+	let bestLeft = before;
+	for (const gap of NUDGE_GAPS) for (const lane of [origin - gap, origin + gap]) {
+		moveSlot(slot, lane);
+		slot.coordinate = lane;
+		const left = isSafe(slot, obstacles, endpoints, baseline) ? stillOverlapping([slot], neighbours) : Infinity;
+		moveSlot(slot, origin);
+		slot.coordinate = origin;
+		if (!left) {
+			apply([slot], [lane]);
+			return;
+		}
+		if (left < bestLeft) {
+			best = lane;
+			bestLeft = left;
+		}
+	}
+	if (best !== origin) apply([slot], [best]);
+}
+function replay(group, memo) {
+	const coordinates = [];
+	for (const slot of group) {
+		if (memo.dirty.has(slot.relationshipId)) return false;
+		const coordinate = memo.coordinate(slot.relationshipId, slot.index, slot.vertical);
+		if (coordinate === void 0) return false;
+		if (memo.lanes.hits(slot.vertical, slot.coordinate, coordinate, slot.low, slot.high)) return false;
+		coordinates.push(coordinate);
+	}
+	apply(group, coordinates);
+	return true;
+}
+function markMoved(group, before, memo) {
+	group.forEach((slot, index) => {
+		const from = before[index];
+		const to = slot.coordinate;
+		if (Math.abs(to - from) < .5) return;
+		memo.lanes.markSpan(slot.vertical, from, to, slot.low, slot.high);
+		const a = slot.points[slot.index];
+		const b = slot.points[slot.index + 1];
+		const low = Math.min(from, to);
+		const high = Math.max(from, to);
+		const first = slot.vertical ? a.y : a.x;
+		const second = slot.vertical ? b.y : b.x;
+		memo.lanes.markSpan(!slot.vertical, first, first, low, high);
+		memo.lanes.markSpan(!slot.vertical, second, second, low, high);
+	});
+}
+function laneModels(group) {
+	const coloured = colourGroup(group);
+	const compact = orderings(coloured);
+	return coloured.length === group.length ? compact : [...compact, ...orderings(group.map((slot) => [slot]))];
+}
+function orderings(tracks) {
+	const mean = (track, of) => track.reduce((total, slot) => total + of(slot), 0) / track.length;
+	const byEntry = [...tracks].sort((a, b) => mean(a, entryOf) - mean(b, entryOf) || mean(a, coordinateOf) - mean(b, coordinateOf) || compareSlots(a[0], b[0]));
+	const byCoordinate = [...tracks].sort((a, b) => mean(a, coordinateOf) - mean(b, coordinateOf) || mean(a, entryOf) - mean(b, entryOf) || compareSlots(a[0], b[0]));
+	return byEntry.every((track, index) => track === byCoordinate[index]) ? [byEntry] : [byEntry, byCoordinate];
+}
+function coordinateOf(slot) {
+	return slot.coordinate;
+}
+function totalDrift(group, originals) {
+	return group.reduce((total, slot, index) => total + Math.abs(slot.coordinate - originals[index]), 0);
+}
+function apply(group, coordinates) {
+	group.forEach((slot, index) => {
+		moveSlot(slot, coordinates[index]);
+		slot.coordinate = coordinates[index];
+	});
+}
+function place(tracks, gap, centre, baselines, obstacles, endpoints) {
+	const first = centre - gap * (tracks.length - 1) / 2;
+	const occupants = tracks.map(() => []);
+	tracks.forEach((track, index) => {
+		for (const slot of track) {
+			const baseline = baselines.get(slot);
+			if (!baseline) continue;
+			const tryLane = (laneIndex) => {
+				if (laneIndex < 0 || laneIndex >= tracks.length) return false;
+				if (occupants[laneIndex].some((other) => crowdsLane(slot, other))) return false;
+				const lane = first + laneIndex * gap;
+				moveSlot(slot, lane);
+				if (!isSafe(slot, obstacles, endpoints, baseline)) return false;
+				slot.coordinate = lane;
+				occupants[laneIndex].push(slot);
+				return true;
+			};
+			let placed = false;
+			for (let drift = 0; drift <= MAX_LANE_DRIFT && !placed; drift++) placed = tryLane(index - drift) || drift > 0 && tryLane(index + drift);
+			if (!placed) moveSlot(slot, slot.coordinate);
+		}
+	});
+}
+function baselineOf(slot, obstacles, endpoints) {
+	const pair = endpoints.get(slot.relationshipId);
+	const own = [];
+	for (let index = 0; index < obstacles.ids.length; index++) {
+		const id = obstacles.ids[index];
+		if (id === pair?.[0] || id === pair?.[1]) own.push(index);
+	}
+	return {
+		blocked: countBlocked(slot.points, obstacles, pair?.[0] ?? "", pair?.[1] ?? ""),
+		crossed: selfCrosses(slot.points),
+		own,
+		intruded: countIntruded(slot.points, obstacles, own),
+		beforeDelta: neighbourDelta(slot, -1),
+		afterDelta: neighbourDelta(slot, 1)
+	};
+}
+function neighbourDelta(slot, side) {
+	const own = slot.points[side < 0 ? slot.index : slot.index + 1];
+	const outer = slot.points[side < 0 ? slot.index - 1 : slot.index + 2];
+	return slot.vertical ? outer.x - own.x : outer.y - own.y;
+}
+function reverses(delta, was) {
+	return Math.abs(was) >= .5 && delta * was <= 0;
+}
+function countIntruded(points, obstacles, own) {
+	let count = 0;
+	for (const index of own) {
+		const left = obstacles.left[index];
+		const top = obstacles.top[index];
+		const right = obstacles.right[index];
+		const bottom = obstacles.bottom[index];
+		for (let i = 1; i < points.length; i++) {
+			const a = points[i - 1];
+			const b = points[i];
+			if (segmentHitsBox(a.x, a.y, b.x, b.y, left, top, right, bottom)) {
+				count++;
+				break;
+			}
+		}
+	}
+	return count;
+}
+function isSafe(slot, obstacles, endpoints, baseline) {
+	const before = slot.points[slot.index - 1];
+	const a = slot.points[slot.index];
+	const b = slot.points[slot.index + 1];
+	const after = slot.points[slot.index + 2];
+	if (slot.vertical ? Math.abs(before.x - a.x) < .5 || Math.abs(after.x - b.x) < .5 : Math.abs(before.y - a.y) < .5 || Math.abs(after.y - b.y) < .5) return false;
+	if (slot.index === 1 && reverses(neighbourDelta(slot, -1), baseline.beforeDelta)) return false;
+	if (slot.index + 2 === slot.points.length - 1 && reverses(neighbourDelta(slot, 1), baseline.afterDelta)) return false;
+	if (countIntruded(slot.points, obstacles, baseline.own) > baseline.intruded) return false;
+	if (!baseline.crossed && selfCrosses(slot.points)) return false;
+	const pair = endpoints.get(slot.relationshipId);
+	return countBlocked(slot.points, obstacles, pair?.[0] ?? "", pair?.[1] ?? "") <= baseline.blocked;
+}
+function selfCrosses(points) {
+	for (let i = 0; i + 1 < points.length; i++) for (let j = i + 2; j + 1 < points.length; j++) if (crosses(points[i], points[i + 1], points[j], points[j + 1])) return true;
+	return false;
+}
+function crosses(a1, a2, b1, b2) {
+	const aVertical = Math.abs(a1.x - a2.x) < .5;
+	if (aVertical === Math.abs(b1.x - b2.x) < .5) return false;
+	const v1 = aVertical ? a1 : b1;
+	const v2 = aVertical ? a2 : b2;
+	const h1 = aVertical ? b1 : a1;
+	const h2 = aVertical ? b2 : a2;
+	return v1.x > Math.min(h1.x, h2.x) && v1.x < Math.max(h1.x, h2.x) && h1.y > Math.min(v1.y, v2.y) && h1.y < Math.max(v1.y, v2.y);
+}
+//#endregion
+export { nudgeRoutes };