@mark1russell7/highways 0.7.0 → 0.8.1

package/build/index.js

@@ -1048,9 +1048,10 @@ function checkProperties(graph, result, limit = 100) {
 				detail: `run ${run.id} has fewer than two edges`
 			})) return out;
 		}
+		let back;
 		for (const id of run.edges) {
 			const r = routes.get(id);
-			if (!r || !(holds$2(r.points, run.points) || holds$2(r.points, [...run.points].reverse()))) {
+			if (!r || !(holds$2(r.points, run.points) || holds$2(r.points, back ??= [...run.points].reverse()))) {
 				if (add({
 					rule: "run-shared",
 					edge: id,
@@ -1115,7 +1116,11 @@ function onBoundary$1(p, b) {
 /** This function tells if the polyline `p` holds the points of `part` in a row. */
 function holds$2(p, part) {
 	if (part.length === 0) return true;
-	for (let i = 0; i + part.length <= p.length; i++) if (part.every((q, j) => dist(q, p[i + j]) <= .5)) return true;
+	for (let i = 0; i + part.length <= p.length; i++) {
+		let j = 0;
+		while (j < part.length && dist(part[j], p[i + j]) <= .5) j++;
+		if (j === part.length) return true;
+	}
 	return false;
 }
 // src/curves/sample.ts
@@ -2043,6 +2048,109 @@ function straightCurve(points) {
 		to
 	});
 }
+// src/compare.ts
+/** This function compares two texts by their UTF-16 code units. It gives 0 only for equal texts. */
+const byText = (a, b) => a < b ? -1 : a > b ? 1 : 0;
+/** This function compares two edges by the hash of their ids, and then by their ids. Thus the order of two edges does not depend on the input. */
+function byHash(a, b) {
+	if (a.h !== b.h) return a.h - b.h;
+	return byText(a.e.id, b.e.id);
+}
+// src/lane-order.ts
+/** Two points nearer than this distance are the same point. The value is the same as in `segments.ts`. */
+const SAME$4 = 1e-6;
+/** The angle, from -π to π, of the turn at `base` from the direction `from` → `base` to the point `to`. */
+function turn$1(from, base, to) {
+	const dx = base.x - from.x;
+	const dy = base.y - from.y;
+	const vx = to.x - base.x;
+	const vy = to.y - base.y;
+	return Math.atan2(dx * vy - dy * vx, dx * vx + dy * vy);
+}
+/** This function gives the place where the routes `P` and `Q` part after the last point of the run, or nothing. */
+function partAfter(P, Q) {
+	for (let j = 1;; j++) {
+		const a = P.p[P.e + j];
+		const b = Q.p[Q.e + j];
+		if (a === void 0 || b === void 0) return void 0;
+		if (a !== b && dist(a, b) > SAME$4) {
+			const from = P.p[P.e + j - 2];
+			const at = P.p[P.e + j - 1];
+			const side = turn$1(from, at, a) - turn$1(from, at, b);
+			return side === 0 ? void 0 : {
+				at,
+				side
+			};
+		}
+	}
+}
+/** This function gives the place where the routes `P` and `Q` part before the first point of the run, or nothing. */
+function partBefore(P, Q) {
+	for (let j = 1;; j++) {
+		const a = P.p[P.s - j];
+		const b = Q.p[Q.s - j];
+		if (a === void 0 || b === void 0) return void 0;
+		if (a !== b && dist(a, b) > SAME$4) {
+			const from = P.p[P.s - j + 2];
+			const at = P.p[P.s - j + 1];
+			const side = turn$1(from, at, b) - turn$1(from, at, a);
+			return side === 0 ? void 0 : {
+				at,
+				side
+			};
+		}
+	}
+}
+/** This function compares two placed routes by their edge ids. */
+const byEdge$2 = (P, Q) => byText(P.edge, Q.edge);
+/** This function puts the point `a` before the point `b`: the smaller x first, then the smaller y. */
+const firstPoint = (a, b) => a.x < b.x - SAME$4 || Math.abs(a.x - b.x) <= SAME$4 && a.y < b.y;
+/**
+* This function is the relation of the order `run`. The side after the run tells the order first, then the side before the run, then the edges.
+* A value below 0 puts `P` before `Q`. The relation is not transitive: three lanes can make a cycle.
+*/
+const byRun = (P, Q) => partAfter(P, Q)?.side ?? partBefore(P, Q)?.side ?? byEdge$2(P, Q);
+/**
+* This function is the relation of the order `bundle`. When the two ends disagree, the end with the smaller x, then the smaller y, tells the side.
+* A value below 0 puts `P` before `Q`. The relation is not transitive: three lanes can make a cycle.
+*/
+const byBundle = (P, Q) => {
+	const after = partAfter(P, Q);
+	const before = partBefore(P, Q);
+	if (after && before && Math.sign(after.side) !== Math.sign(before.side)) return firstPoint(after.at, before.at) ? after.side : before.side;
+	return after?.side ?? before?.side ?? byEdge$2(P, Q);
+};
+/**
+* This function sorts a list with a stable merge sort of the package, not with `Array.prototype.sort`.
+* The pairs that it gives to `compare` depend only on the list and on the results of `compare`.
+* Thus the result is the same on each JavaScript engine, also when `compare` is not a total order.
+* A value of `compare(a, b)` above 0 puts `b` before `a`. Any other value (below 0, 0 or NaN) keeps `a` first.
+*/
+function mergeSort(list, compare) {
+	if (list.length < 2) return [...list];
+	const mid = list.length >> 1;
+	const left = mergeSort(list.slice(0, mid), compare);
+	const right = mergeSort(list.slice(mid), compare);
+	const out = [];
+	let i = 0;
+	let j = 0;
+	while (i < left.length && j < right.length) if (compare(left[i], right[j]) > 0) out.push(right[j++]);
+	else out.push(left[i++]);
+	while (i < left.length) out.push(left[i++]);
+	while (j < right.length) out.push(right[j++]);
+	return out;
+}
+/** This function gives the lane order of a run: the merge sort of `start` with the relation `compare`. It tells the observer of `observeLanes`. */
+function orderRun(start, compare) {
+	return mergeSort(start, compare);
+}
+/**
+* This function gives the lane order of the placed routes of a run. `order` selects the relation.
+* With `run`, the sort starts from the order of `placed`. With `bundle`, it starts from the order of the edges, so that each run sorts the same edges the same way.
+*/
+function orderPlaced(placed, order) {
+	return order === "run" ? orderRun(placed, byRun) : orderRun([...placed].sort(byEdge$2), byBundle);
+}
 // src/segments.ts
 const SAME$3 = 1e-6;
 /** This function gives the index where `p` holds the points of `part` in a row, from `from` on, or -1. */
@@ -2223,6 +2331,7 @@ function laneRoutes(source, open, laneWidth, maxWidth = Infinity) {
 /** This function gives the route of each path, with the lanes of each segment at the spacing that `spacingOf` gives. */
 function lanePaths(graph, spacingOf) {
 	const byId = new Map(graph.segments.map((s) => [s.id, s]));
+	const spacings = /* @__PURE__ */ new Map();
 	const routes = [];
 	for (const path of graph.paths) {
 		const ends = pathPoints(graph, path);
@@ -2230,7 +2339,8 @@ function lanePaths(graph, spacingOf) {
 		for (const ref of path.segments) {
 			const s = byId.get(ref.segment);
 			if (!s) continue;
-			const spacing = spacingOf(s);
+			let spacing = spacings.get(s);
+			if (spacing === void 0) spacings.set(s, spacing = spacingOf(s));
 			const moved = offsetPolyline(s.points, ((s.count - 1) / 2 - ref.lane) * spacing);
 			for (const q of ref.reverse ? moved.reverse() : moved) if (out.length === 0 || dist(q, out[out.length - 1]) > SAME$3) out.push(q);
 		}
@@ -2245,51 +2355,6 @@ function lanePaths(graph, spacingOf) {
 	}
 	return routes;
 }
-/** The angle, from -π to π, of the turn at `base` from the direction `from` → `base` to the point `to`. */
-function turn$1(from, base, to) {
-	const dx = base.x - from.x;
-	const dy = base.y - from.y;
-	const vx = to.x - base.x;
-	const vy = to.y - base.y;
-	return Math.atan2(dx * vy - dy * vx, dx * vx + dy * vy);
-}
-/** This function gives the place where the routes `P` and `Q` part after the last point of the run, or nothing. */
-function partAfter(P, Q) {
-	for (let j = 1;; j++) {
-		const a = P.p[P.e + j];
-		const b = Q.p[Q.e + j];
-		if (a === void 0 || b === void 0) return void 0;
-		if (dist(a, b) > SAME$3) {
-			const from = P.p[P.e + j - 2];
-			const at = P.p[P.e + j - 1];
-			const side = turn$1(from, at, a) - turn$1(from, at, b);
-			return side === 0 ? void 0 : {
-				at,
-				side
-			};
-		}
-	}
-}
-/** This function gives the place where the routes `P` and `Q` part before the first point of the run, or nothing. */
-function partBefore(P, Q) {
-	for (let j = 1;; j++) {
-		const a = P.p[P.s - j];
-		const b = Q.p[Q.s - j];
-		if (a === void 0 || b === void 0) return void 0;
-		if (dist(a, b) > SAME$3) {
-			const from = P.p[P.s - j + 2];
-			const at = P.p[P.s - j + 1];
-			const side = turn$1(from, at, b) - turn$1(from, at, a);
-			return side === 0 ? void 0 : {
-				at,
-				side
-			};
-		}
-	}
-}
-const byEdge$2 = (P, Q) => P.edge < Q.edge ? -1 : P.edge > Q.edge ? 1 : 0;
-/** This function puts the point `a` before the point `b`: the smaller x first, then the smaller y. */
-const firstPoint = (a, b) => a.x < b.x - SAME$3 || Math.abs(a.x - b.x) <= SAME$3 && a.y < b.y;
 /**
 * This function gives the lane order of the edges on a shared way `run` (metro-line order).
 * The routes are polylines that hold the points of the run in a row, in either direction. A route that does not hold the run goes last.
@@ -2300,6 +2365,11 @@ const firstPoint = (a, b) => a.x < b.x - SAME$3 || Math.abs(a.x - b.x) <= SAME$3
 * With the order `bundle`, two routes that part on one side at both ends keep that side.
 * When the two ends disagree, the two routes must cross. The end with the smaller x, then the smaller y, tells the side.
 * Thus each shared way of a common stretch gives two routes the same order, and the crossing is where they part.
+*
+* This relation of two lanes is not transitive, so three lanes can make a cycle. The sort of the engine then gives another order on another engine.
+* Thus the function sorts with a merge sort of the package (LANE-ORDER). The order is the same on each JavaScript engine.
+* On a run with no cycle, the order is the order of each correct sort, for each order of `routes`.
+* On a run with a cycle, the order depends on the order of `routes`. The item LANE-STRETCH is to remove the cycles.
 */
 function orderLanes(run, routes, order = "run") {
 	const placed = [];
@@ -2324,17 +2394,7 @@ function orderLanes(run, routes, order = "run") {
 			else lost.push(r.edge);
 		}
 	}
-	if (order === "run") placed.sort((P, Q) => partAfter(P, Q)?.side ?? partBefore(P, Q)?.side ?? byEdge$2(P, Q));
-	else {
-		placed.sort(byEdge$2);
-		placed.sort((P, Q) => {
-			const after = partAfter(P, Q);
-			const before = partBefore(P, Q);
-			if (after && before && Math.sign(after.side) !== Math.sign(before.side)) return firstPoint(after.at, before.at) ? after.side : before.side;
-			return after?.side ?? before?.side ?? byEdge$2(P, Q);
-		});
-	}
-	return [...placed.map((x) => x.edge), ...lost.sort()];
+	return [...orderPlaced(placed, order).map((x) => x.edge), ...lost.sort()];
 }
 // src/curves/highway/index.ts
 /** A turn smaller than this angle, in radians, is no corner. A turn nearer to a half turn than this angle stays sharp. */
@@ -6123,7 +6183,6 @@ function snellMerges(ways, firstId, clear, delta) {
 	}
 }
 // src/routers/shared.ts
-const byText = (a, b) => a < b ? -1 : a > b ? 1 : 0;
 /** The angle, from -π to π, of the turn at `base` from the direction `from` → `base` to the point `to`. */
 function turn(from, base, to) {
 	const dx = base.x - from.x;
@@ -6268,31 +6327,42 @@ function sharedRouter(options) {
 				const pad = ways.margin / 2;
 				snellMerges(order, corners.points.length + ends.size, (a, b) => ways.obstacles.clear(a, b, pad), (f) => Math.min(.95, share(f)));
 			}
+			const N = corners.points.length + ends.size + 1;
+			const pairOf = (a, b) => a < b ? a * N + b : b * N + a;
 			const users = /* @__PURE__ */ new Map();
 			for (const w of order) {
 				if (!w.found) continue;
 				let mine = users.get(w.key);
 				if (!mine) users.set(w.key, mine = /* @__PURE__ */ new Map());
 				for (let i = 1; i < w.ids.length; i++) {
-					const a = w.ids[i - 1];
-					const b = w.ids[i];
-					const k = a < b ? `${a}:${b}` : `${b}:${a}`;
+					const k = pairOf(w.ids[i - 1], w.ids[i]);
 					const list = mine.get(k);
 					if (list) list.push(w.edge.id);
 					else mine.set(k, [w.edge.id]);
 				}
 			}
+			const texts = /* @__PURE__ */ new Map();
+			const sigs = /* @__PURE__ */ new Map();
+			for (const [key, mine] of users) {
+				const own = /* @__PURE__ */ new Map();
+				for (const [k, list] of mine) {
+					if (list.length < 2) {
+						own.set(k, 0);
+						continue;
+					}
+					const text = [...list].sort(byText).join("
");
+					let n = texts.get(text);
+					if (n === void 0) texts.set(text, n = texts.size + 1);
+					own.set(k, n);
+				}
+				sigs.set(key, own);
+			}
 			const runs = /* @__PURE__ */ new Map();
 			const points = /* @__PURE__ */ new Map();
 			for (const w of all) {
 				if (!w.found) continue;
-				const used = users.get(w.key);
-				const sig = (i) => {
-					const a = w.ids[i];
-					const b = w.ids[i + 1];
-					const list = used.get(a < b ? `${a}:${b}` : `${b}:${a}`);
-					return list.length < 2 ? "" : [...list].sort(byText).join("
");
-				};
+				const own = sigs.get(w.key);
+				const sig = (i) => own.get(pairOf(w.ids[i], w.ids[i + 1]));
 				const out = [w.ps.point];
 				const append = (piece) => {
 					for (const p of piece) if (dist(p, out[out.length - 1]) > 1e-9) out.push(p);
@@ -6302,7 +6372,7 @@ function sharedRouter(options) {
 					const s = sig(i);
 					if (i + 1 < w.seq.length - 1 && sig(i + 1) === s) continue;
 					const raw = w.seq.slice(start, i + 2);
-					if (s === "") append(corners.pull(raw));
+					if (s === 0) append(corners.pull(raw));
 					else {
 						const a = w.ids[start];
 						const b = w.ids[i + 1];
@@ -6428,7 +6498,7 @@ function laneOrderOfRun(run) {
 		}
 		return byText(p.edge.id, q.edge.id);
 	};
-	return [...run.ways].sort(compare).map((w) => w.edge.id);
+	return orderRun(run.ways, compare).map((w) => w.edge.id);
 }
 // src/routers/straight.ts
 /** This function gives the point where the ray from the center of the box to `toward` leaves the box. */
@@ -9460,14 +9530,28 @@ function sharedStretches(ways, o) {
 	}
 	const stretches = /* @__PURE__ */ new Map();
 	const wayOf = /* @__PURE__ */ new Map();
+	const texts = /* @__PURE__ */ new Map();
+	const sigs = /* @__PURE__ */ new Map();
+	const sigOf = (k) => {
+		let n = sigs.get(k);
+		if (n !== void 0) return n;
+		const list = users.get(k) ?? [];
+		if (list.length < min) n = 0;
+		else {
+			const text = [...list].sort().join("
");
+			n = texts.get(text);
+			if (n === void 0) texts.set(text, n = texts.size + 1);
+		}
+		sigs.set(k, n);
+		return n;
+	};
 	for (const w of clean) {
 		wayOf.set(w.edge, w.points);
 		const sig = (i) => {
 			const a = w.points[i];
 			const b = w.points[i + 1];
-			if (!usable(a, b)) return "";
-			const list = users.get(`${w.key}\u0000${linkKey(pointKey(a), pointKey(b))}`) ?? [];
-			return list.length < min ? "" : [...list].sort().join("
");
+			if (!usable(a, b)) return 0;
+			return sigOf(`${w.key}\u0000${linkKey(pointKey(a), pointKey(b))}`);
 		};
 		let start = 0;
 		for (let i = 0; i < w.points.length - 1; i++) {
@@ -9475,7 +9559,7 @@ function sharedStretches(ways, o) {
 			if (i + 1 < w.points.length - 1 && sig(i + 1) === s) continue;
 			const from = start;
 			start = i + 1;
-			if (s === "") continue;
+			if (s === 0) continue;
 			const a = pointKey(w.points[from]);
 			const b = pointKey(w.points[i + 1]);
 			if (a === b) continue;
@@ -9485,13 +9569,17 @@ function sharedStretches(ways, o) {
 			if (!found) stretches.set(id, found = {
 				key: w.key,
 				points: a < b ? piece : [...piece].reverse(),
-				members: []
-			});
-			if (!found.members.some((m) => m.edge === w.edge)) found.members.push({
-				edge: w.edge,
-				forward: a < b,
-				at: from
+				members: [],
+				seen: /* @__PURE__ */ new Set()
 			});
+			if (!found.seen.has(w.edge)) {
+				found.seen.add(w.edge);
+				found.members.push({
+					edge: w.edge,
+					forward: a < b,
+					at: from
+				});
+			}
 		}
 	}
 	const kept = [...stretches.values()].filter((s) => s.members.length >= min);
@@ -22999,11 +23087,6 @@ function round3(value) {
 	return r === 0 ? 0 : r;
 }
 // src/order/index.ts
-/** This function compares two edges by the hash of their ids, and then by their ids. Thus the order of two edges does not depend on the input. */
-function byHash(a, b) {
-	if (a.h !== b.h) return a.h - b.h;
-	return a.e.id < b.e.id ? -1 : a.e.id > b.e.id ? 1 : 0;
-}
 /**
 * This function gives the graph with its edges in the stable order of WILD-053: by the FNV-1a hash of the id, then by the id.
 * The nodes and the edges do not change. Two orders of the same edges give the same graph.
@@ -26995,9 +27078,12 @@ function distancesTo(points, adj, start, targets) {
 	const done = new Uint8Array(adj.length);
 	const goal = new Set(targets);
 	const ends = targets.map((t) => points[t]);
+	const guides = new Float64Array(adj.length).fill(-1);
 	const guide = (v) => {
+		if (guides[v] >= 0) return guides[v];
 		let h = Infinity;
 		for (const t of ends) h = Math.min(h, dist(points[v], t));
+		guides[v] = h;
 		return h;
 	};
 	const heap = new NodeHeap();