reladraw 0.14.0 → 0.14.2

package/README.md

@@ -82,7 +82,7 @@ That gets you a copy of the skill at the time you run it, so you'll need to re-r
 
 ## Status
 
-Version 0.14.0. Early stage, but works. The parser, layout engine, and SVG renderer are written in TypeScript, with zero runtime dependencies. There is a command-line tool that turns a .reladraw text file into an SVG, and an element that does the same inside a web page.
+Version 0.14.2. Early stage, but works. The parser, layout engine, and SVG renderer are written in TypeScript, with zero runtime dependencies. There is a command-line tool that turns a .reladraw text file into an SVG, and an element that does the same inside a web page.
 
 The language isn't stable yet, so expect the syntax to change.
 

package/SYNTAX.md

@@ -1,4 +1,4 @@
-# Syntax reference — 0.14.0
+# Syntax reference — 0.14.2
 
 What the language accepts. The parser, resolver and SVG renderer implement all of it; the sections at the end record what is defective, unchecked or undecided.
 
@@ -1112,6 +1112,20 @@ That one was found by testing the lexer, not by rendering — and it could not h
 
 Pre-1.0, so the minor number is where a breaking change goes. Every removal below is refused by name with the replacement quoted, rather than dropped in silence — an older file stops with an error saying what to write instead.
 
+**0.14.2**
+
+No syntax changes, and no file that worked is refused.
+
+- Many copies of one line draw far faster. Lines with the same two ends, the same sides, the same clauses and no text are now drawn as one line and its copies, each a lane further out, instead of each finding its own way round the copies before it. Fifteen copies of `edge a -> b  from: left  to: right` took about a third of a second and forty took two and a half; forty now take half a second. Where such copies used to split, some going over the top and some underneath, they now stay together. A copy that would run into a box or cross a line the first one does not is still found as before.
+- Curved lines in busy diagrams draw faster. No picture changes.
+
+**0.14.1**
+
+No syntax changes, and no file that worked is refused.
+
+- Diagrams with many lines draw far faster. Since 0.13.0, the time to find the lines' ways grew much faster than the number of lines: a tangled diagram of 45 boxes and 48 lines took over half an hour. It now takes a few seconds, and ten lines take under one. No example diagram draws differently.
+- After every line is placed, lines that cross are placed again in the other order, to cross fewer. That now stops after as many attempts as there are lines. In a very tangled diagram a line may cross another where 0.13.0 and 0.14.0 found a way round; `from:`/`to:`, `below` and `between` say where a line should go.
+
 **0.14.0**
 
 One breaking change: on an edge written with `<-`, `from:` and `to:` now name the sides of the first and second names written. They used to follow the arrow, so `disk <- writer  from: bottom` meant Writer's bottom; it now means Disk's. Swap the two on any `<-` edge that names a side. No other file draws differently.

package/dist/render.js

@@ -1704,6 +1704,9 @@ function planWays(edges, nodes, ends, corridors, measurer, fontSize) {
             ...(edge.passes ?? []).map((pass) => pass.written),
         ].join(' ');
     };
+    // Each line of such a group after the first, and the line it is drawn as a
+    // copy of: the one a lane inside it.
+    const copies = new Map();
     for (let index = 0; index < wanted.length; index += 1) {
         const key = sameWay(wanted[index]);
         const group = wanted.filter((edge) => sameWay(edge) === key);
@@ -1723,6 +1726,14 @@ function planWays(edges, nodes, ends, corridors, measurer, fontSize) {
         rest.splice(index, 0, ...ordered);
         wanted.splice(0, wanted.length, ...rest);
         index += group.length - 1;
+        // A text widens the lane it rides in, which a copy cannot know; those are searched.
+        const named = (edge) => {
+            const { start, end } = ends.get(edge);
+            return start.side !== undefined && end.side !== undefined;
+        };
+        if (ordered.every((edge) => edge.lines === undefined && named(edge))) {
+            ordered.slice(1).forEach((edge, at) => copies.set(edge, ordered[at]));
+        }
     }
     // Where several lines leave one side, their ends may be squeezed closer than
     // a lane; the lines then run out of them that close together, and the lanes
@@ -1843,22 +1854,90 @@ function planWays(edges, nodes, ends, corridors, measurer, fontSize) {
         found.set(edge, way);
         ends.set(edge, { start: way.start, end: way.end });
     };
+    // A line identical to one already placed is that line moved out by a lane,
+    // not a search of its own: the same way, every stretch shifted to the same
+    // side by the distance between their ends. Searching each afresh, keeping
+    // clear of every copy before it, made fifteen identical lines take as long as
+    // a tangled diagram. Where the copy would not do — its ends do not line up
+    // with the shift, a stretch folds up, it meets a box, crowds or crosses a line
+    // the first does not — the line is searched for as any other.
+    const copyOf = (edge, inside, placed) => {
+        const { start, end } = planned.get(edge);
+        const base = found.get(inside).points;
+        const count = base.length - 1;
+        if (count < 1)
+            return undefined;
+        const heading = base.slice(1).map((q, index) => {
+            const p = base[index];
+            const length = Math.hypot(q.x - p.x, q.y - p.y);
+            return { x: (q.x - p.x) / length, y: (q.y - p.y) / length, length };
+        });
+        if (heading.some((one) => one.length < 0.5 || (Math.abs(one.x) > 1e-6 && Math.abs(one.y) > 1e-6)))
+            return undefined;
+        const normal = heading.map((one) => ({ x: -one.y, y: one.x }));
+        const along = (from, to, axis) => (to.x - from.x) * axis.x + (to.y - from.y) * axis.y;
+        const shift = along(base[0], start, normal[0]);
+        if (Math.abs(shift) < 0.5 || Math.abs(along(base[0], start, heading[0])) > 0.5)
+            return undefined;
+        if (Math.abs(along(base[count], end, normal[count - 1]) - shift) > 0.5 || Math.abs(along(base[count], end, heading[count - 1])) > 0.5) {
+            return undefined;
+        }
+        const points = [{ x: start.x, y: start.y }];
+        for (let index = 1; index < count; index += 1) {
+            const [p, q] = [normal[index - 1], normal[index]];
+            const turns = Math.abs(p.x * q.x + p.y * q.y) < 0.5;
+            const v = base[index];
+            points.push(turns ? { x: v.x + shift * (p.x + q.x), y: v.y + shift * (p.y + q.y) } : { x: v.x + shift * q.x, y: v.y + shift * q.y });
+        }
+        points.push({ x: end.x, y: end.y });
+        for (let index = 0; index < count; index += 1) {
+            const [p, q] = [points[index], points[index + 1]];
+            if (along(p, q, heading[index]) < 0.5)
+                return undefined;
+        }
+        const inner = points.slice(1, -1);
+        const walls = nodes
+            .filter((node) => !contains(node, edge.from) && !contains(node, edge.to))
+            .map((node) => grow(extentOfBox(faceOf(node)), ATTACH_MARGIN - 0.5));
+        const own = [edge.from, edge.to].map((node) => grow(extentOfBox(faceOf(node)), ATTACH_MARGIN - 0.5));
+        const fences = (edge.passes ?? []).map((pass) => fenceOf(pass, 0));
+        if (!wayClear(points, [...obstaclesFor(edge, nodes), ...walls]) || !wayClear(inner, [...own, ...fences]) || !passesAll(edge, points)) {
+            return undefined;
+        }
+        const lane = laneFor(edge);
+        for (const other of placed) {
+            const theirs = found.get(other).points;
+            if (linesCross(points, theirs) > linesCross(base, theirs))
+                return undefined;
+            if (other !== inside && crowds(points, theirs, lane))
+                return undefined;
+        }
+        return { start, end, points, mid: textOnWay(points, edge, nodes, measurer, fontSize) };
+    };
     for (const edge of wanted) {
-        settle(edge, place(edge, [...order]));
+        const inside = copies.get(edge);
+        const copy = inside && found.has(inside) ? copyOf(edge, inside, [...order]) : undefined;
+        settle(edge, copy ?? place(edge, [...order]));
         order.push(edge);
     }
     // Which line takes the inside of a shared stretch depends on which was placed
     // first, and the wrong order makes two lines cross where they need not. So a
     // pair that crosses is placed again the other way round, and kept that way if
-    // it crosses less.
+    // it crosses less. This is tidying, not a promise: the pairs are tried a
+    // fixed number of times over, however tangled the diagram, since trying every
+    // pair that crossed made a diagram of forty lines take minutes. A count, not a
+    // clock, so a file draws the same on every machine. A writer who wants a line
+    // somewhere in particular says so.
     const crossingsOf = (edge) => order.reduce((sum, other) => (other === edge ? sum : sum + linesCross(found.get(edge).points, found.get(other).points)), 0);
-    for (let pass = 0; pass < 3; pass += 1) {
+    let tries = order.length * UNCROSS_TRIES;
+    for (let pass = 0; pass < 3 && tries > 0; pass += 1) {
         let better = false;
-        for (let i = 0; i < order.length; i += 1) {
-            for (let j = i + 1; j < order.length; j += 1) {
+        for (let i = 0; i < order.length && tries > 0; i += 1) {
+            for (let j = i + 1; j < order.length && tries > 0; j += 1) {
                 const [first, second] = [order[i], order[j]];
                 if (linesCross(found.get(first).points, found.get(second).points) === 0)
                     continue;
+                tries -= 1;
                 const before = crossingsOf(first) + crossingsOf(second);
                 const kept = [found.get(first), found.get(second)];
                 const rest = order.filter((edge) => edge !== first && edge !== second);
@@ -1894,6 +1973,27 @@ function planWays(edges, nodes, ends, corridors, measurer, fontSize) {
     }
     return routes;
 }
+/**
+ * Whether two lines run side by side, along the same stretch, nearer than a
+ * lane apart — which a line found by search never does.
+ */
+function crowds(a, b, lane) {
+    for (let i = 0; i + 1 < a.length; i += 1) {
+        const [p, q] = [a[i], a[i + 1]];
+        const level = Math.abs(p.y - q.y) < 0.5;
+        for (let j = 0; j + 1 < b.length; j += 1) {
+            const [r, s] = [b[j], b[j + 1]];
+            if (level !== Math.abs(r.y - s.y) < 0.5)
+                continue;
+            const [across, lo, hi, otherAcross, otherLo, otherHi] = level
+                ? [p.y, Math.min(p.x, q.x), Math.max(p.x, q.x), r.y, Math.min(r.x, s.x), Math.max(r.x, s.x)]
+                : [p.x, Math.min(p.y, q.y), Math.max(p.y, q.y), r.x, Math.min(r.y, s.y), Math.max(r.y, s.y)];
+            if (Math.min(hi, otherHi) - Math.max(lo, otherLo) > 0.5 && Math.abs(across - otherAcross) < lane - 0.5)
+                return true;
+        }
+    }
+    return false;
+}
 /** How many times two lines cross, each drawn as straight pieces through its points. */
 function linesCross(a, b) {
     let count = 0;
@@ -2196,6 +2296,8 @@ function textOnWay(points, edge, nodes, measurer, fontSize) {
 }
 /** How much a turn costs the search, in the same units as length. */
 const SEARCH_TURN = SEPARATION_GAP * 2;
+/** How many crossing pairs, per line placed, may be placed again the other way round. */
+const UNCROSS_TRIES = 1;
 /**
  * The searched way for one edge, or one half of a `between` edge. A named side
  * is fixed; an end with no side named may leave or arrive by any of its box's
@@ -2302,6 +2404,9 @@ function searchWay(edge, nodes, start, startNode, end, endNode, taken, lane, use
                 taken,
                 lane,
                 ...more,
+                // Only a way cheaper than the best so far is taken, so a search that
+                // cannot find one stops early.
+                limit: best ? best.cost - 1e-6 : Infinity,
                 bounds: wallOf(grow(nodes.map((node) => extentOfBox(faceOf(node))).reduce(union), ROUTE_STUB * 4)),
             });
             if (found && (!best || found.cost < best.cost - 1e-6))
@@ -2551,9 +2656,21 @@ function sweptPath(points, boxes, neighbors, arrow, marks) {
                 return false;
             }
         }
+        // A piece of another line wholly beyond the curve's reach, and its air,
+        // can neither cross it nor come near it.
+        const reach = {
+            minX: Math.min(...trace.map((point) => point.x)) - SWEEP_AIR,
+            maxX: Math.max(...trace.map((point) => point.x)) + SWEEP_AIR,
+            minY: Math.min(...trace.map((point) => point.y)) - SWEEP_AIR,
+            maxY: Math.max(...trace.map((point) => point.y)) + SWEEP_AIR,
+        };
         for (const line of neighbors) {
             for (let index = 0; index + 1 < line.length; index += 1) {
                 const [p, q] = [line[index], line[index + 1]];
+                if (Math.max(p.x, q.x) < reach.minX || Math.min(p.x, q.x) > reach.maxX)
+                    continue;
+                if (Math.max(p.y, q.y) < reach.minY || Math.min(p.y, q.y) > reach.maxY)
+                    continue;
                 for (let step = 0; step < steps; step += 1) {
                     if (intersect(trace[step], trace[step + 1], p, q))
                         return false;

package/dist/search.d.ts

@@ -79,6 +79,12 @@ export interface SearchOptions {
      * cannot be gone round at its far end.
      */
     bounds?: SearchWall;
+    /**
+     * A cost the line is no use at unless it comes in under: the cheapest way
+     * already found between another pair of sides. The search gives up as soon
+     * as it cannot.
+     */
+    limit?: number;
 }
 /** A gap a line must pass through. See `SearchOptions.gate`. */
 export interface SearchGate {

package/dist/search.js

@@ -45,6 +45,10 @@ export function searchRoute(start, end, walls, options) {
         return undefined;
     if (inside(out, walls) || inside(back, walls))
         return undefined;
+    // No way between the two is shorter than straight across and straight down.
+    const limit = options.limit ?? Infinity;
+    if (Math.abs(back.x - out.x) + Math.abs(back.y - out.y) - 1e-6 >= limit)
+        return undefined;
     const bounds = options.bounds;
     const gate = options.gate;
     // How far a stretch keeps from a placed one beside it: a lane, or clear of
@@ -68,7 +72,8 @@ export function searchRoute(start, end, walls, options) {
     const iy = new Map(ys.map((y, index) => [y, index]));
     const width = xs.length;
     const height = ys.length;
-    const open = (i, j) => !inside({ x: xs[i], y: ys[j] }, walls);
+    const steps = stepTable(xs, ys, walls, clear, options.taken, spacing, ownHalf, (a, b) => (inGate(a, b) ? ownHalf : 0));
+    const open = (i, j) => steps.open[j * width + i] === 1;
     // Four headings: 0 right, 1 down, 2 left, 3 up.
     const STEP = [
         [1, 0],
@@ -95,26 +100,40 @@ export function searchRoute(start, end, walls, options) {
     const from = new Int32Array(size).fill(-1);
     const state = (i, j, h, p) => ((j * width + i) * 4 + h) * 2 + p;
     const done = gate ? 1 : 0;
+    // The search reaches out toward the end first: a state waits by what it has
+    // cost so far plus the least the rest could cost, straight across and
+    // straight down to the end. It does not settle each state once, since a
+    // way just as long can arrive later with a better tie-break; it keeps on
+    // until nothing waiting could come in as cheap as the end already has, and
+    // what it finds is exactly what searching every direction alike would.
+    const toGo = (current) => {
+        const cell = (current - (current % 8)) / 8;
+        const i = cell % width;
+        return Math.abs(xs[i] - back.x) + Math.abs(ys[(cell - i) / width] - back.y);
+    };
     const heap = new MinHeap();
     const begin = state(si, sj, first, 0);
+    const goal = state(ti, tj, last, done);
     cost[begin] = 0;
     tie[begin] = 0;
-    heap.push(begin, 0, 0);
-    let goal = -1;
+    heap.push(begin, toGo(begin), 0);
     while (heap.size > 0) {
-        const [current, c, t] = heap.pop();
-        if (c > cost[current] || (c === cost[current] && t > tie[current]))
+        const [current, f, t] = heap.pop();
+        const c = cost[current];
+        const due = c + toGo(current);
+        if (f > due || (f === due && t > tie[current]))
             continue;
+        // Everything still waiting costs at least this much.
+        if (f >= limit || f > cost[goal] + 1e-9)
+            break;
         const p = current % 2;
         const rest = (current - p) / 2;
         const h = rest % 4;
         const cell = (rest - h) / 4;
         const i = cell % width;
         const j = (cell - i) / width;
-        if (i === ti && j === tj && h === last && p === done) {
-            goal = current;
-            break;
-        }
+        if (current === goal)
+            continue;
         for (let next = 0; next < 4; next += 1) {
             // A line never doubles straight back on itself.
             if ((next + 2) % 4 === h)
@@ -128,11 +147,13 @@ export function searchRoute(start, end, walls, options) {
             const nj = j + STEP[next][1];
             if (ni < 0 || nj < 0 || ni >= width || nj >= height || !open(ni, nj))
                 continue;
+            // A step is filed under the point it starts from on its way right or down.
+            const axis = next % 2;
+            const key = next < 2 ? j * width + i : nj * width + ni;
+            if (steps.closed[axis][key] === 1)
+                continue;
             const a = { x: xs[i], y: ys[j] };
             const b = { x: xs[ni], y: ys[nj] };
-            const own = inGate(a, b) ? ownHalf : 0;
-            if (blocked(a, b, walls) || alongTaken(a, b, options.taken, spacing, own))
-                continue;
             // Passing the gate: a stretch through it, reaching the line at `at`.
             const through = inGate(a, b) &&
                 Math.min(gate.run === 'x' ? a.x : a.y, gate.run === 'x' ? b.x : b.y) <= gate.at + 0.01 &&
@@ -142,8 +163,8 @@ export function searchRoute(start, end, walls, options) {
             // a narrow gap, but where there is room it keeps its distance. Crossing a
             // line already placed costs what a turn does, so of two ways much the
             // same length the one that crosses nothing wins.
-            const length = Math.abs(b.x - a.x) + Math.abs(b.y - a.y) + crowding(a, b, walls, clear) +
-                turn * crossings(a, b, options.taken);
+            const length = Math.abs(b.x - a.x) + Math.abs(b.y - a.y) + steps.crowd[axis][key] +
+                turn * steps.cross[axis][key];
             // Higher up for a stretch across, further right for one down: a smaller
             // tie-break is preferred, so the across level counts as it is and the
             // down level counts negated.
@@ -151,14 +172,14 @@ export function searchRoute(start, end, walls, options) {
             relax(current, state(ni, nj, next, np), c + length, t + lean);
         }
     }
-    if (goal < 0)
+    if (!(cost[goal] < limit))
         return undefined;
     function relax(previous, next, c, t) {
         if (c < cost[next] - 1e-9 || (Math.abs(c - cost[next]) <= 1e-9 && t < tie[next])) {
             cost[next] = c;
             tie[next] = t;
             from[next] = previous;
-            heap.push(next, c, t);
+            heap.push(next, c + toGo(next), t);
         }
     }
     const path = [];
@@ -255,83 +276,139 @@ function inside(point, walls) {
 }
 /** Whether a level or upright stretch passes through the inside of any wall. */
 function blocked(a, b, walls) {
+    return walls.some((wall) => blocks(a, b, wall));
+}
+/** Whether a level or upright stretch passes through the inside of one wall. */
+function blocks(a, b, wall) {
     const minX = Math.min(a.x, b.x);
     const maxX = Math.max(a.x, b.x);
     const minY = Math.min(a.y, b.y);
     const maxY = Math.max(a.y, b.y);
-    return walls.some((wall) => {
-        if (minY === maxY)
-            return minY > wall.minY && minY < wall.maxY && maxX > wall.minX && minX < wall.maxX;
-        return minX > wall.minX && minX < wall.maxX && maxY > wall.minY && minY < wall.maxY;
-    });
+    if (minY === maxY)
+        return minY > wall.minY && minY < wall.maxY && maxX > wall.minX && minX < wall.maxX;
+    return minX > wall.minX && minX < wall.maxX && maxY > wall.minY && minY < wall.maxY;
 }
 /**
- * How much of a stretch runs within `clear` of a wall's side, alongside it:
- * the longest such run against any one wall.
+ * Every single step through the grid — from a point to its neighbor on the
+ * right, or the one below — and what it costs beyond its length: whether it is
+ * closed, by a wall or by running along a placed line; how far it runs close
+ * beside a wall; how many placed lines it crosses. The search takes each step
+ * many times over, once for each heading it arrives with, so these are worked
+ * out here once, and each wall and each placed stretch is tested only against
+ * the steps that lie near it. A step is filed at the index of the point it
+ * starts from: `[0]` the step right, `[1]` the step down.
  */
-function crowding(a, b, walls, clear) {
+function stepTable(xs, ys, walls, clear, taken, spacing, widest, ownAt) {
+    const width = xs.length;
+    const height = ys.length;
+    const cells = width * height;
+    const open = new Uint8Array(cells).fill(1);
+    const closed = [new Uint8Array(cells), new Uint8Array(cells)];
+    const crowd = [new Float64Array(cells), new Float64Array(cells)];
+    const cross = [new Int32Array(cells), new Int32Array(cells)];
+    // The indices of the tracks lying within `lo`..`hi`, with one to spare either
+    // side: a range to test exactly, never a test itself.
+    const near = (values, lo, hi) => [Math.max(0, firstAtLeast(values, lo) - 1), Math.min(values.length - 1, firstAtLeast(values, hi) + 1)];
+    const each = ([i0, i1], [j0, j1], visit) => {
+        for (let j = j0; j <= j1; j += 1) {
+            for (let i = i0; i <= i1; i += 1) {
+                const a = { x: xs[i], y: ys[j] };
+                if (i + 1 < width)
+                    visit(0, a, { x: xs[i + 1], y: ys[j] }, j * width + i);
+                if (j + 1 < height)
+                    visit(1, a, { x: xs[i], y: ys[j + 1] }, j * width + i);
+            }
+        }
+    };
+    for (const wall of walls) {
+        const [i0, i1] = near(xs, wall.minX, wall.maxX);
+        const [j0, j1] = near(ys, wall.minY, wall.maxY);
+        for (let j = j0; j <= j1; j += 1) {
+            for (let i = i0; i <= i1; i += 1) {
+                const x = xs[i];
+                const y = ys[j];
+                if (x > wall.minX && x < wall.maxX && y > wall.minY && y < wall.maxY)
+                    open[j * width + i] = 0;
+            }
+        }
+        each([i0, i1], [j0, j1], (axis, a, b, key) => {
+            if (blocks(a, b, wall))
+                closed[axis][key] = 1;
+        });
+        each(near(xs, wall.minX - clear, wall.maxX + clear), near(ys, wall.minY - clear, wall.maxY + clear), (axis, a, b, key) => {
+            crowd[axis][key] = Math.max(crowd[axis][key], crowding(a, b, wall, clear));
+        });
+    }
+    taken.forEach((line, which) => {
+        for (let index = 0; index + 1 < line.length; index += 1) {
+            const [p, q] = [line[index], line[index + 1]];
+            const reach = spacing(which, index, widest);
+            const xr = near(xs, Math.min(p.x, q.x) - reach, Math.max(p.x, q.x) + reach);
+            const yr = near(ys, Math.min(p.y, q.y) - reach, Math.max(p.y, q.y) + reach);
+            each(xr, yr, (axis, a, b, key) => {
+                if (runsAlong(a, b, p, q, spacing(which, index, ownAt(a, b))))
+                    closed[axis][key] = 1;
+                if (crosses(a, b, p, q))
+                    cross[axis][key] = cross[axis][key] + 1;
+            });
+        }
+    });
+    return { open, closed, crowd, cross };
+}
+/** The index of the first of the sorted values at least `value`, or their count if none is. */
+function firstAtLeast(values, value) {
+    let lo = 0;
+    let hi = values.length;
+    while (lo < hi) {
+        const mid = (lo + hi) >> 1;
+        if (values[mid] < value)
+            lo = mid + 1;
+        else
+            hi = mid;
+    }
+    return lo;
+}
+/** How much of a stretch runs within `clear` of one wall's side, alongside it; 0 if none does. */
+function crowding(a, b, wall, clear) {
     const across = Math.abs(a.y - b.y) < 0.5;
     const level = across ? a.y : a.x;
     const from = across ? Math.min(a.x, b.x) : Math.min(a.y, b.y);
     const to = across ? Math.max(a.x, b.x) : Math.max(a.y, b.y);
-    let worst = 0;
-    for (const wall of walls) {
-        const [lo, hi] = across ? [wall.minY, wall.maxY] : [wall.minX, wall.maxX];
-        const [alo, ahi] = across ? [wall.minX, wall.maxX] : [wall.minY, wall.maxY];
-        const near = (level > lo - clear + 0.01 && level <= lo) || (level >= hi && level < hi + clear - 0.01);
-        if (!near)
-            continue;
-        worst = Math.max(worst, Math.min(to, ahi) - Math.max(from, alo));
-    }
-    return worst;
+    const [lo, hi] = across ? [wall.minY, wall.maxY] : [wall.minX, wall.maxX];
+    const [alo, ahi] = across ? [wall.minX, wall.maxX] : [wall.minY, wall.maxY];
+    const near = (level > lo - clear + 0.01 && level <= lo) || (level >= hi && level < hi + clear - 0.01);
+    return near ? Math.max(0, Math.min(to, ahi) - Math.max(from, alo)) : 0;
 }
 /**
- * Whether a stretch runs along a placed line, for any distance, closer than
- * the spacing between the two there: a lane, or clear of a text either carries.
+ * Whether a stretch runs along one stretch of a placed line, for any distance,
+ * closer than `spacing`: a lane, or clear of a text either carries.
  */
-function alongTaken(a, b, taken, spacing, own) {
+function runsAlong(a, b, p, q, spacing) {
     const across = Math.abs(a.y - b.y) < 0.5;
+    if ((Math.abs(p.y - q.y) < 0.5) !== across)
+        return false;
     const level = across ? a.y : a.x;
+    const other = across ? p.y : p.x;
+    if (Math.abs(other - level) >= spacing - 0.5)
+        return false;
     const lo = across ? Math.min(a.x, b.x) : Math.min(a.y, b.y);
     const hi = across ? Math.max(a.x, b.x) : Math.max(a.y, b.y);
-    for (const [which, line] of taken.entries()) {
-        for (let index = 0; index + 1 < line.length; index += 1) {
-            const [p, q] = [line[index], line[index + 1]];
-            const pAcross = Math.abs(p.y - q.y) < 0.5;
-            if (pAcross !== across)
-                continue;
-            const other = across ? p.y : p.x;
-            if (Math.abs(other - level) >= spacing(which, index, own) - 0.5)
-                continue;
-            const pLo = across ? Math.min(p.x, q.x) : Math.min(p.y, q.y);
-            const pHi = across ? Math.max(p.x, q.x) : Math.max(p.y, q.y);
-            if (Math.min(hi, pHi) - Math.max(lo, pLo) > 0.5)
-                return true;
-        }
-    }
-    return false;
+    const pLo = across ? Math.min(p.x, q.x) : Math.min(p.y, q.y);
+    const pHi = across ? Math.max(p.x, q.x) : Math.max(p.y, q.y);
+    return Math.min(hi, pHi) - Math.max(lo, pLo) > 0.5;
 }
-/** How many stretches of placed lines a stretch crosses square on, touching neither end of either. */
-function crossings(a, b, taken) {
+/** Whether a stretch crosses one stretch of a placed line square on, touching neither end of either. */
+function crosses(a, b, p, q) {
     const across = Math.abs(a.y - b.y) < 0.5;
+    if ((Math.abs(p.y - q.y) < 0.5) === across)
+        return false;
     const level = across ? a.y : a.x;
     const lo = across ? Math.min(a.x, b.x) : Math.min(a.y, b.y);
     const hi = across ? Math.max(a.x, b.x) : Math.max(a.y, b.y);
-    let found = 0;
-    for (const line of taken) {
-        for (let index = 0; index + 1 < line.length; index += 1) {
-            const [p, q] = [line[index], line[index + 1]];
-            const pAcross = Math.abs(p.y - q.y) < 0.5;
-            if (pAcross === across)
-                continue;
-            const at = across ? p.x : p.y;
-            const pLo = across ? Math.min(p.y, q.y) : Math.min(p.x, q.x);
-            const pHi = across ? Math.max(p.y, q.y) : Math.max(p.x, q.x);
-            if (at > lo + 0.5 && at < hi - 0.5 && level > pLo + 0.5 && level < pHi - 0.5)
-                found += 1;
-        }
-    }
-    return found;
+    const at = across ? p.x : p.y;
+    const pLo = across ? Math.min(p.y, q.y) : Math.min(p.x, q.x);
+    const pHi = across ? Math.max(p.y, q.y) : Math.max(p.x, q.x);
+    return at > lo + 0.5 && at < hi - 0.5 && level > pLo + 0.5 && level < pHi - 0.5;
 }
 /** The points with every one dropped that sits on a straight run between its neighbors. */
 function straightRuns(points) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "reladraw",
-  "version": "0.14.0",
+  "version": "0.14.2",
   "description": "A diagram language where you say where things go.",
   "type": "module",
   "bin": {