@yalehwang/plantuml-js 0.2.2 → 0.3.1

package/dist/layout/lane-spread.js

@@ -0,0 +1,302 @@
+/**
+ * Lane spreading. The grid router and ELK both let unrelated orthogonal edges
+ * share one channel centre, so several edges end up drawn on top of each other
+ * and read as one thicker line. This pass fans such coincident (or nearly
+ * coincident) interior segments out onto distinct, evenly spaced lanes around
+ * their common centre. Only interior segments move — the first and last
+ * segments stay attached to their ports — and a move is dropped when it would
+ * run through a node or fold an adjacent segment back on itself.
+ */
+/** Segments closer than this on the cross axis are one lane cluster (just above PARALLEL_PROXIMITY). */
+const CLUSTER_DISTANCE = 10;
+/** Distance between spread lanes; strictly above [[CLUSTER_DISTANCE]] so lanes stay distinct. */
+const LANE_STEP = 10;
+/** Tightest lane step used when a corridor is too narrow (still above PARALLEL_PROXIMITY = 8). */
+const MIN_LANE_STEP = 8.5;
+/** An adjacent segment may shrink to at most this length. */
+const MIN_STUB = 6;
+/** Clearance between a moved segment and an unrelated node box. */
+const NODE_CLEARANCE = 12;
+/** Clearance between a moved segment and a package frame border it runs along. */
+const FRAME_CLEARANCE = 10;
+/** Spreading is repeated because moved lanes can land beside a neighbouring channel. */
+const PASSES = 2;
+export function spreadParallelLanes(layout) {
+    const polylines = layout.edges.map((e) => dropRepeats(e.points));
+    const owners = layout.edges.map((e) => new Set([e.source, e.target]));
+    const ends = layout.edges.map((e) => [e.source, e.target]);
+    let changed = layout.edges.some((e, i) => e.points.length !== polylines[i].length);
+    for (let pass = 0; pass < PASSES; pass++) {
+        let moved = false;
+        for (const horizontal of [true, false]) {
+            const segs = withoutMergedTrunks(collectSegments(polylines, horizontal), ends);
+            for (const cluster of clusterSegments(segs)) {
+                if (spreadCluster(cluster, polylines, owners, layout, horizontal))
+                    moved = true;
+            }
+        }
+        if (!moved)
+            break;
+        changed = true;
+    }
+    if (!changed)
+        return layout;
+    return { ...layout, edges: layout.edges.map((e, i) => ({ ...e, points: polylines[i] })) };
+}
+/** Copy of `points` without consecutive duplicates (zero-length segments). */
+function dropRepeats(points) {
+    const out = [];
+    for (const p of points) {
+        const last = out[out.length - 1];
+        if (!last || Math.abs(last.x - p.x) > 1e-6 || Math.abs(last.y - p.y) > 1e-6)
+            out.push({ ...p });
+    }
+    return out.length >= 2 || points.length < 2 ? out : points.map((p) => ({ ...p }));
+}
+function collectSegments(polylines, horizontal) {
+    const segs = [];
+    const cross = (p) => (horizontal ? p.y : p.x);
+    const along = (p) => (horizontal ? p.x : p.y);
+    polylines.forEach((pts, edge) => {
+        // Interior segments only: both neighbours must exist.
+        for (let i = 1; i + 2 < pts.length; i++) {
+            const a = pts[i];
+            const b = pts[i + 1];
+            if (Math.abs(cross(a) - cross(b)) > 1e-6)
+                continue;
+            const prev = pts[i - 1];
+            const next = pts[i + 2];
+            // Neighbours must be perpendicular (they absorb the shift).
+            if (Math.abs(along(prev) - along(a)) > 1e-6 || Math.abs(along(next) - along(b)) > 1e-6)
+                continue;
+            const c = cross(a);
+            const side = (p) => Math.sign(cross(p) - c);
+            segs.push({
+                edge,
+                at: i,
+                c,
+                lo: Math.min(along(a), along(b)),
+                hi: Math.max(along(a), along(b)),
+                turn: side(prev) + side(next),
+            });
+        }
+    });
+    return segs;
+}
+/**
+ * Drops segments lying exactly on a segment of another edge with the same source
+ * (or target): that overlap is a deliberately shared trunk, not a clash to fan out.
+ */
+function withoutMergedTrunks(segs, ends) {
+    const merged = new Set();
+    const order = segs.slice().sort((a, b) => a.c - b.c);
+    for (let x = 0; x < order.length; x++) {
+        for (let y = x + 1; y < order.length && order[y].c - order[x].c < 0.5; y++) {
+            const s = order[x];
+            const t = order[y];
+            if (s.edge === t.edge || Math.min(s.hi, t.hi) - Math.max(s.lo, t.lo) <= 1)
+                continue;
+            const [sa, sb] = ends[s.edge];
+            const [ta, tb] = ends[t.edge];
+            if (sa === ta || sb === tb) {
+                merged.add(s);
+                merged.add(t);
+            }
+        }
+    }
+    return merged.size === 0 ? segs : segs.filter((s) => !merged.has(s));
+}
+/** Groups of segments (from at least two edges) that overlap within [[CLUSTER_DISTANCE]]. */
+function clusterSegments(segs) {
+    const order = segs.map((_, i) => i).sort((a, b) => segs[a].c - segs[b].c);
+    const parent = segs.map((_, i) => i);
+    const find = (i) => {
+        while (parent[i] !== i)
+            i = parent[i] = parent[parent[i]];
+        return i;
+    };
+    for (let x = 0; x < order.length; x++) {
+        const s = segs[order[x]];
+        for (let y = x + 1; y < order.length; y++) {
+            const t = segs[order[y]];
+            if (t.c - s.c >= CLUSTER_DISTANCE)
+                break;
+            if (s.edge === t.edge)
+                continue;
+            if (Math.min(s.hi, t.hi) - Math.max(s.lo, t.lo) > 1)
+                parent[find(order[x])] = find(order[y]);
+        }
+    }
+    const groups = new Map();
+    segs.forEach((s, i) => {
+        const root = find(i);
+        const list = groups.get(root);
+        if (list)
+            list.push(s);
+        else
+            groups.set(root, [s]);
+    });
+    return [...groups.values()].filter((g) => new Set(g.map((s) => s.edge)).size > 1);
+}
+function spreadCluster(cluster, polylines, owners, layout, horizontal) {
+    const lanes = cluster
+        .slice()
+        .sort((a, b) => a.c - b.c || a.turn - b.turn || a.edge - b.edge || a.at - b.at);
+    const targets = fitToCorridor(separate(lanes.map((s) => s.c), LANE_STEP), lanes, layout, horizontal);
+    let moved = false;
+    lanes.forEach((seg, k) => {
+        const target = targets[k];
+        if (Math.abs(target - seg.c) < 1e-6)
+            return;
+        if (shift(polylines[seg.edge], seg.at, target, owners[seg.edge], layout, horizontal))
+            moved = true;
+    });
+    return moved;
+}
+/**
+ * Least-squares positions for the sorted coordinates `c` such that neighbours
+ * are at least `step` apart (pool-adjacent-violators on `c − step·i`).
+ */
+function separate(c, step) {
+    const blocks = [];
+    c.forEach((v, i) => {
+        blocks.push({ sum: v - step * i, n: 1 });
+        while (blocks.length > 1) {
+            const b = blocks[blocks.length - 1];
+            const a = blocks[blocks.length - 2];
+            if (a.sum / a.n <= b.sum / b.n)
+                break;
+            a.sum += b.sum;
+            a.n += b.n;
+            blocks.pop();
+        }
+    });
+    const out = [];
+    for (const b of blocks)
+        for (let k = 0; k < b.n; k++)
+            out.push(b.sum / b.n + step * out.length);
+    return out;
+}
+/**
+ * Keep `targets` (sorted lanes) inside the free corridor around the cluster:
+ * the gap between the nearest unrelated boxes on either side. A corridor too
+ * narrow for [[LANE_STEP]] is shared at a tighter step down to [[MIN_LANE_STEP]];
+ * when even that does not fit the unconstrained targets are returned (the
+ * per-segment safety checks then decide what can move).
+ */
+function fitToCorridor(targets, lanes, layout, horizontal) {
+    const n = targets.length;
+    const lo = Math.min(...lanes.map((s) => s.lo));
+    const hi = Math.max(...lanes.map((s) => s.hi));
+    const centre = lanes.reduce((sum, s) => sum + s.c, 0) / n;
+    const blocked = [];
+    const add = (a0, a1, c0, c1, clearance) => {
+        if (a1 > lo && a0 < hi)
+            blocked.push([c0 - clearance, c1 + clearance]);
+    };
+    for (const b of layout.nodes) {
+        if (horizontal)
+            add(b.x, b.x + b.width, b.y, b.y + b.height, NODE_CLEARANCE);
+        else
+            add(b.y, b.y + b.height, b.x, b.x + b.width, NODE_CLEARANCE);
+    }
+    for (const f of layout.packages ?? []) {
+        if (horizontal) {
+            add(f.x, f.x + f.width, f.y, f.y, FRAME_CLEARANCE);
+            add(f.x, f.x + f.width, f.y + f.height, f.y + f.height, FRAME_CLEARANCE);
+        }
+        else {
+            add(f.y, f.y + f.height, f.x, f.x, FRAME_CLEARANCE);
+            add(f.y, f.y + f.height, f.x + f.width, f.x + f.width, FRAME_CLEARANCE);
+        }
+    }
+    let floor = -Infinity;
+    let ceil = Infinity;
+    for (const [a, b] of blocked) {
+        if (a <= centre && centre <= b)
+            return targets;
+        if (b < centre)
+            floor = Math.max(floor, b);
+        else
+            ceil = Math.min(ceil, a);
+    }
+    const room = ceil - floor;
+    const needed = (n - 1) * LANE_STEP;
+    if (room >= needed) {
+        const first = targets[0];
+        const last = targets[n - 1];
+        const shiftBy = first < floor ? floor - first : last > ceil ? ceil - last : 0;
+        return targets.map((t) => t + shiftBy);
+    }
+    if (n < 2 || room / (n - 1) < MIN_LANE_STEP)
+        return targets;
+    const step = room / (n - 1);
+    return targets.map((_, i) => floor + i * step);
+}
+/** Move segment `at` of `pts` to cross-axis `target`; false (and unchanged) if that is unsafe. */
+function shift(pts, at, target, owner, layout, horizontal) {
+    const key = horizontal ? 'y' : 'x';
+    const a = pts[at];
+    const b = pts[at + 1];
+    const prev = pts[at - 1];
+    const next = pts[at + 2];
+    // The segment may have moved already (shared with an earlier lane); read live coordinates.
+    const keepsDirection = (far, near) => {
+        const before = near[key] - far[key];
+        const after = target - far[key];
+        return Math.sign(before) === Math.sign(after) && Math.abs(after) >= MIN_STUB;
+    };
+    if (!keepsDirection(prev, a) || !keepsDirection(next, b))
+        return false;
+    const trial = [
+        { ...prev },
+        { ...a, [key]: target },
+        { ...b, [key]: target },
+        { ...next },
+    ];
+    for (const n of layout.nodes) {
+        if (owner.has(n.id))
+            continue;
+        const box = {
+            x0: n.x - NODE_CLEARANCE,
+            y0: n.y - NODE_CLEARANCE,
+            x1: n.x + n.width + NODE_CLEARANCE,
+            y1: n.y + n.height + NODE_CLEARANCE,
+        };
+        for (let i = 0; i + 1 < trial.length; i++)
+            if (segmentHitsBox(trial[i], trial[i + 1], box))
+                return false;
+    }
+    if (runsAlongFrame(trial[1], trial[2], layout, horizontal) ||
+        runsAlongFrame(trial[0], trial[1], layout, !horizontal) ||
+        runsAlongFrame(trial[2], trial[3], layout, !horizontal)) {
+        return false;
+    }
+    a[key] = target;
+    b[key] = target;
+    return true;
+}
+/** True when the moved segment would hug a package frame border it is parallel to. */
+function runsAlongFrame(p, q, layout, horizontal) {
+    for (const f of layout.packages ?? []) {
+        if (horizontal) {
+            if (Math.max(p.x, q.x) <= f.x || Math.min(p.x, q.x) >= f.x + f.width)
+                continue;
+            if (Math.abs(p.y - f.y) < FRAME_CLEARANCE || Math.abs(p.y - (f.y + f.height)) < FRAME_CLEARANCE)
+                return true;
+        }
+        else {
+            if (Math.max(p.y, q.y) <= f.y || Math.min(p.y, q.y) >= f.y + f.height)
+                continue;
+            if (Math.abs(p.x - f.x) < FRAME_CLEARANCE || Math.abs(p.x - (f.x + f.width)) < FRAME_CLEARANCE)
+                return true;
+        }
+    }
+    return false;
+}
+function segmentHitsBox(p, q, box) {
+    return (Math.max(p.x, q.x) > box.x0 &&
+        Math.min(p.x, q.x) < box.x1 &&
+        Math.max(p.y, q.y) > box.y0 &&
+        Math.min(p.y, q.y) < box.y1);
+}

package/dist/layout/package-endpoints.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Package-endpoint clipping. A relation that names a package (`X --> B` with
+ * `package ... as X`) is laid out against a representative entity inside it,
+ * so the routed polyline ends on that entity's box. The author meant the
+ * package, so the polyline is cut where it crosses the package frame: the edge
+ * visibly starts/ends on the frame boundary instead of reaching into it.
+ */
+import { PlantUmlModel } from '../foundation/model.js';
+import { LayoutResult } from '../foundation/layout.js';
+export declare function clipPackageEndpoints(model: PlantUmlModel, layout: LayoutResult): LayoutResult;

package/dist/layout/package-endpoints.js

@@ -0,0 +1,54 @@
+/**
+ * Package-endpoint clipping. A relation that names a package (`X --> B` with
+ * `package ... as X`) is laid out against a representative entity inside it,
+ * so the routed polyline ends on that entity's box. The author meant the
+ * package, so the polyline is cut where it crosses the package frame: the edge
+ * visibly starts/ends on the frame boundary instead of reaching into it.
+ */
+const inside = (p, r) => p.x > r.x && p.x < r.x + r.width && p.y > r.y && p.y < r.y + r.height;
+/** Point where segment a→b (a inside `r`, b outside) leaves the rectangle. */
+function exitPoint(a, b, r) {
+    let t = 1;
+    const dx = b.x - a.x;
+    const dy = b.y - a.y;
+    if (dx > 0)
+        t = Math.min(t, (r.x + r.width - a.x) / dx);
+    if (dx < 0)
+        t = Math.min(t, (r.x - a.x) / dx);
+    if (dy > 0)
+        t = Math.min(t, (r.y + r.height - a.y) / dy);
+    if (dy < 0)
+        t = Math.min(t, (r.y - a.y) / dy);
+    return { x: a.x + dx * t, y: a.y + dy * t };
+}
+/** Cut the head of `points` at the first exit from `r`; unchanged if it never leaves. */
+function clipHead(points, r) {
+    if (points.length < 2 || !inside(points[0], r))
+        return points;
+    for (let i = 1; i < points.length; i++) {
+        if (!inside(points[i], r)) {
+            return [exitPoint(points[i - 1], points[i], r), ...points.slice(i)];
+        }
+    }
+    return points;
+}
+export function clipPackageEndpoints(model, layout) {
+    if (!model.relations.some((r) => r.sourcePackageId || r.targetPackageId))
+        return layout;
+    const boxes = new Map((layout.packages ?? []).map((p) => [p.id, p]));
+    const edges = layout.edges.map((edge) => {
+        const m = /^rel-(\d+)$/.exec(edge.id);
+        const rel = m ? model.relations[Number(m[1])] : undefined;
+        if (!rel)
+            return edge;
+        let points = edge.points;
+        const src = rel.sourcePackageId ? boxes.get(rel.sourcePackageId) : undefined;
+        const dst = rel.targetPackageId ? boxes.get(rel.targetPackageId) : undefined;
+        if (src)
+            points = clipHead(points, src);
+        if (dst)
+            points = clipHead([...points].reverse(), dst).reverse();
+        return points === edge.points ? edge : { ...edge, points };
+    });
+    return { ...layout, edges };
+}

package/dist/layout/placement-strategy.d.ts

@@ -0,0 +1,98 @@
+/**
+ * Block placement strategy extension point for the compound layout.
+ *
+ * The compound layout lays each top-level package out as a block, then has to
+ * decide where the blocks go: orbit stubs, stack semantic layers, rect-pack the
+ * blocks, or let ELK's layered algorithm place them. Each of those is a
+ * [[PlacementStrategy]]; the first one to return a placement wins and
+ * `undefined` declines to the next. New placement behaviour is added by
+ * injecting strategies through `CompoundOptions.placementStrategies` (tried
+ * before the built-in chain) instead of editing `placeBlocks`' decision chain.
+ * A strategy that throws is not swallowed: the error propagates out of the
+ * layout.
+ *
+ * The same interface also covers the smaller "pack the boxes inside one block"
+ * dimension ([[BoxPlacementContext]]), so the ordered shelf pack and the
+ * equal-column grid are strategies too rather than branches in `layoutBlock`.
+ */
+import type { ELK as ElkInstance, ElkNode } from 'elkjs';
+import type { PlantUmlModel } from '../foundation/model.js';
+import type { NodeLayout, PackageLayout, Point } from '../foundation/layout.js';
+/** Channel to the frame (`gap`) and spacing between neighbouring stubs (`spacing`), px. */
+export interface StubOrbit {
+    gap: number;
+    spacing: number;
+    /** Row/column a stub slides to: its targets' centroid (default) or the target nearest its side. */
+    anchor?: 'centroid' | 'nearest';
+}
+/** One top-level block as laid out on its own, ready to be placed. */
+export interface Block {
+    /** Block key: package id, or entity id for a bare top-level entity. */
+    key: string;
+    width: number;
+    height: number;
+    nodes: NodeLayout[];
+    packages: PackageLayout[];
+    /** Intra-block edge polylines keyed by relation index, block-local coordinates. */
+    edges: Map<number, Point[]>;
+    /** Intra-block relations the block layout left for the grid router. */
+    unrouted?: number[];
+}
+/** Where every placed block (or box) sits, and the canvas size that needs. */
+export interface Placement {
+    positions: Map<string, Point>;
+    width: number;
+    height: number;
+}
+/** Knobs a strategy may consult; `CompoundOptions` satisfies this shape. */
+export interface PlacementStrategyOptions {
+    /** Pack every flat block tightly (very large graphs). */
+    dense?: boolean;
+    /** Dense blocks use rect packing instead of dependency-ordered rows. */
+    rectPackDense?: boolean;
+    /** Target canvas width/height (ELK `elk.aspectRatio`). */
+    aspectRatio?: number;
+    /** Raw ELK options injected into each block's root and package containers. */
+    elk?: Record<string, string>;
+    /** Block id → semantic-layer partition index. */
+    partitions: ReadonlyMap<string, number>;
+    /** Where stub nodes orbit the placed blocks; the caller resolves the default. */
+    stubOrbit?: StubOrbit;
+}
+/** What the layout tells a block placement strategy about the run it is part of. */
+export interface PlacementStrategyContext {
+    readonly elk: ElkInstance;
+    readonly model: PlantUmlModel;
+    readonly blocks: ReadonlyMap<string, Block>;
+    readonly crossRelations: readonly number[];
+    readonly blockOfEntity: ReadonlyMap<string, string>;
+    readonly options: PlacementStrategyOptions;
+    /**
+     * The chain this strategy runs in. A strategy may re-enter it for a
+     * sub-placement (stub orbit places the main blocks first).
+     */
+    readonly strategies: readonly PlacementStrategy[];
+}
+/** What a box placement strategy is given: the boxes of one block, in dependency order. */
+export interface BoxPlacementContext {
+    /** The boxes to arrange; their order is preserved when they are materialised. */
+    readonly boxes: readonly ElkNode[];
+    /** Box ids in dependency order. */
+    readonly order: readonly string[];
+    /** Target canvas width/height. */
+    readonly aspect: number;
+    /** Gap between boxes, px. */
+    readonly gap: number;
+    /** Row gap, when it differs from `gap`. */
+    readonly rowGap?: number;
+    /** Size each column to its own widest box (grid pack only). */
+    readonly tight?: boolean;
+}
+export interface PlacementStrategy<C = PlacementStrategyContext> {
+    /** Short identifier, used in diagnostics. */
+    readonly name: string;
+    /** Place the blocks/boxes, or return `undefined` to decline. */
+    place(ctx: C): Placement | undefined | Promise<Placement | undefined>;
+}
+/** First non-declining placement, or `undefined` when all decline. */
+export declare function runPlacementStrategies<C>(strategies: readonly PlacementStrategy<C>[] | undefined, ctx: C): Promise<Placement | undefined>;

package/dist/layout/placement-strategy.js

@@ -0,0 +1,26 @@
+/**
+ * Block placement strategy extension point for the compound layout.
+ *
+ * The compound layout lays each top-level package out as a block, then has to
+ * decide where the blocks go: orbit stubs, stack semantic layers, rect-pack the
+ * blocks, or let ELK's layered algorithm place them. Each of those is a
+ * [[PlacementStrategy]]; the first one to return a placement wins and
+ * `undefined` declines to the next. New placement behaviour is added by
+ * injecting strategies through `CompoundOptions.placementStrategies` (tried
+ * before the built-in chain) instead of editing `placeBlocks`' decision chain.
+ * A strategy that throws is not swallowed: the error propagates out of the
+ * layout.
+ *
+ * The same interface also covers the smaller "pack the boxes inside one block"
+ * dimension ([[BoxPlacementContext]]), so the ordered shelf pack and the
+ * equal-column grid are strategies too rather than branches in `layoutBlock`.
+ */
+/** First non-declining placement, or `undefined` when all decline. */
+export async function runPlacementStrategies(strategies, ctx) {
+    for (const strategy of strategies ?? []) {
+        const result = await strategy.place(ctx);
+        if (result !== undefined)
+            return result;
+    }
+    return undefined;
+}

package/dist/layout/strategy.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Layout strategy extension point for the ELK engine.
+ *
+ * A strategy is tried before the engine's built-in decision chain; the first
+ * one that returns a result wins, `undefined` declines and falls through. New
+ * layout strategies are added by injecting them through
+ * `ElkLayoutOptions.strategies` (or `createRenderer({ layoutOptions })`)
+ * instead of editing `ElkLayoutEngine`. A strategy that throws is not
+ * swallowed: the error propagates out of the render.
+ */
+import type { PlantUmlModel } from '../foundation/model.js';
+import type { LayoutResult } from '../foundation/layout.js';
+/** What the engine tells a strategy about the run it is part of. */
+export interface LayoutStrategyContext {
+    /** Semantic layer order resolved for the model. */
+    layers: string[];
+    /** Layer partition index per entity id. */
+    partitions: Map<string, number>;
+}
+export interface LayoutStrategy {
+    /** Short identifier, used in diagnostics. */
+    readonly name: string;
+    /** Lay the model out, or return `undefined` to decline. */
+    layout(model: PlantUmlModel, ctx: LayoutStrategyContext): Promise<LayoutResult | undefined>;
+}
+/** First non-declining strategy result, or `undefined` when all decline. */
+export declare function runStrategies(strategies: readonly LayoutStrategy[] | undefined, model: PlantUmlModel, ctx: LayoutStrategyContext): Promise<LayoutResult | undefined>;

package/dist/layout/strategy.js

@@ -0,0 +1,19 @@
+/**
+ * Layout strategy extension point for the ELK engine.
+ *
+ * A strategy is tried before the engine's built-in decision chain; the first
+ * one that returns a result wins, `undefined` declines and falls through. New
+ * layout strategies are added by injecting them through
+ * `ElkLayoutOptions.strategies` (or `createRenderer({ layoutOptions })`)
+ * instead of editing `ElkLayoutEngine`. A strategy that throws is not
+ * swallowed: the error propagates out of the render.
+ */
+/** First non-declining strategy result, or `undefined` when all decline. */
+export async function runStrategies(strategies, model, ctx) {
+    for (const strategy of strategies ?? []) {
+        const result = await strategy.layout(model, ctx);
+        if (result !== undefined)
+            return result;
+    }
+    return undefined;
+}

package/dist/layout/trunk-lanes.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Trunk lanes. A router that has to dodge a cluster of nodes can leave an edge
+ * that overshoots — out sideways, down, back across, down again — and stacked
+ * edges doing this draw the concentric rectangles of a coil. When the two end
+ * segments run the same axis, the edge is re-drawn as a Z: leave the source,
+ * cross over on a lane between the rows (the gap between the two end points),
+ * and enter the target. It runs after lane spreading and fan-out merging, so only
+ * what those passes left as an overshoot is touched. A Z replaces a detour only when it is shorter, passes
+ * no unrelated node or package frame, and adds at most [[EXTRA_CROSSINGS]] crossings.
+ */
+import { LayoutResult } from '../foundation/layout.js';
+export declare function straightenTrunkDetours(layout: LayoutResult): LayoutResult;
+/**
+ * Lift segments that run flush along the side of a node the edge belongs to —
+ * hard to tell from the box outline — a few pixels off that side. The segment
+ * moves outwards; when it was the first or last one, the original end point is
+ * kept and joined by a short stub. The nearest lift that clears every node and
+ * every parallel neighbour edge is used; none, and the segment stays.
+ */
+export declare function liftFlushSegments(layout: LayoutResult): LayoutResult;
+/**
+ * Un-coil: an edge whose route wraps round other nodes (the U of a trunk that
+ * circles a cluster — stacked, the concentric rectangles of a coil) is routed
+ * again on the lattice with cheaper crossings, against every other edge as a
+ * fixed wire. The new route is kept when it wraps fewer nodes, adds at most
+ * [[UNCOIL_EXTRA_CROSSINGS]] crossings and opens no new comb at either end.
+ * Runs after fan-out merging, so a hub's trunk has been settled by then.
+ */
+export declare function uncoilWraps(layout: LayoutResult): LayoutResult;