@expofp/wayfinding-compiler 0.0.0-experimental.3b0db16 → 0.0.0-stage

package/dist/lib/blockers.js

@@ -1,289 +0,0 @@
-// What a straight run may not cross — walls, outlines of destinations nobody walks through, doorway
-// gaps — indexed by the cells they cover, and the rays and boxes read through the index.
-import { rayVsSegment, ringEdges, segmentsCross } from './geom/primitives.js';
-import { NODE_SNAP } from './graph-types.js';
-/** {@link SegmentGrid} cell side, meters: a booth or two, so a query reads a few cells. */
-const GRID_CELL = 4;
-/** Padding a segment is filed with, so a hit a hair past its end or on a cell border still finds it. */
-const GRID_PAD = 1e-3;
-/** What a blocker segment is. */
-export var BlockerKind;
-(function (BlockerKind) {
-    BlockerKind[BlockerKind["Wall"] = 0] = "Wall";
-    BlockerKind[BlockerKind["Solid"] = 1] = "Solid";
-    BlockerKind[BlockerKind["Gap"] = 2] = "Gap";
-})(BlockerKind || (BlockerKind = {}));
-/**
- * Blocker segments bucketed by the cells their bounds cover. It only narrows the candidates: a segment it
- * leaves out has bounds apart from the query's, so no test could hold for it.
- */
-export class SegmentGrid {
-    /** Every blocker segment, in {@link Blockers} order: walls, then outlines, then gaps. */
-    segs = [];
-    /** What each segment is. */
-    from = [];
-    /** Owning destination of a solid edge; empty for walls and gaps. */
-    owner = [];
-    cells = new Map();
-    seen;
-    stamp = 0;
-    /** Bounds of the filed cells, so a ray knows when it has left them all. */
-    c0 = Infinity;
-    c1 = -Infinity;
-    r0 = Infinity;
-    r1 = -Infinity;
-    constructor(blockers) {
-        const add = (seg, from, owner) => {
-            this.segs.push(seg);
-            this.from.push(from);
-            this.owner.push(owner);
-        };
-        for (const wall of blockers.walls)
-            add(wall, BlockerKind.Wall, '');
-        for (const poi of blockers.solid)
-            for (const edge of poi.edges)
-                add(edge, BlockerKind.Solid, poi.id);
-        for (const gap of blockers.gaps)
-            add(gap, BlockerKind.Gap, '');
-        this.seen = new Int32Array(this.segs.length);
-        // The cells the segments reach: a query looks no farther.
-        for (const seg of this.segs) {
-            this.c0 = Math.min(this.c0, Math.floor((Math.min(seg[0], seg[2]) - GRID_PAD) / GRID_CELL));
-            this.c1 = Math.max(this.c1, Math.floor((Math.max(seg[0], seg[2]) + GRID_PAD) / GRID_CELL));
-            this.r0 = Math.min(this.r0, Math.floor((Math.min(seg[1], seg[3]) - GRID_PAD) / GRID_CELL));
-            this.r1 = Math.max(this.r1, Math.floor((Math.max(seg[1], seg[3]) + GRID_PAD) / GRID_CELL));
-        }
-        this.segs.forEach((seg, i) => this.cover(Math.min(seg[0], seg[2]) - GRID_PAD, Math.min(seg[1], seg[3]) - GRID_PAD, Math.max(seg[0], seg[2]) + GRID_PAD, Math.max(seg[1], seg[3]) + GRID_PAD, (key) => {
-            const list = this.cells.get(key);
-            if (list)
-                list.push(i);
-            else
-                this.cells.set(key, [i]);
-        }));
-    }
-    cover(x0, y0, x1, y1, visit) {
-        const c0 = Math.max(this.c0, Math.floor(x0 / GRID_CELL));
-        const c1 = Math.min(this.c1, Math.floor(x1 / GRID_CELL));
-        const r0 = Math.max(this.r0, Math.floor(y0 / GRID_CELL));
-        const r1 = Math.min(this.r1, Math.floor(y1 / GRID_CELL));
-        for (let c = c0; c <= c1; c++)
-            for (let r = r0; r <= r1; r++)
-                visit(c * 1_000_003 + r);
-    }
-    /**
-     * Walk the cells a ray passes through, nearest first, handing each segment once.
-     * @param ox Ray origin x.
-     * @param oy Ray origin y.
-     * @param nx Ray direction x.
-     * @param ny Ray direction y.
-     * @param from Ray parameter to start at.
-     * @param visit Gets a cell's new segments and the parameter where the ray leaves it; true stops.
-     */
-    alongRay(ox, oy, nx, ny, from, visit) {
-        const sx = ox + nx * from;
-        const sy = oy + ny * from;
-        let c = Math.floor(sx / GRID_CELL);
-        let r = Math.floor(sy / GRID_CELL);
-        const stepC = nx > 0 ? 1 : nx < 0 ? -1 : 0;
-        const stepR = ny > 0 ? 1 : ny < 0 ? -1 : 0;
-        // Ray parameter at the next column/row border, and its growth per cell.
-        const border = (p, d, cell) => d > 0 ? ((cell + 1) * GRID_CELL - p) / d : d < 0 ? (cell * GRID_CELL - p) / d : Infinity;
-        let nextC = from + border(sx, nx, c);
-        let nextR = from + border(sy, ny, r);
-        const perC = nx ? GRID_CELL / Math.abs(nx) : Infinity;
-        const perR = ny ? GRID_CELL / Math.abs(ny) : Infinity;
-        this.stamp++;
-        // A ray going nowhere meets only what its start cell holds.
-        const still = !stepC && !stepR;
-        for (;;) {
-            const fresh = [];
-            for (const i of this.cells.get(c * 1_000_003 + r) ?? []) {
-                if (this.seen[i] === this.stamp)
-                    continue;
-                this.seen[i] = this.stamp;
-                fresh.push(i);
-            }
-            if (visit(fresh, Math.min(nextC, nextR)) || still)
-                return;
-            if (nextC < nextR) {
-                c += stepC;
-                nextC += perC;
-            }
-            else {
-                r += stepR;
-                nextR += perR;
-            }
-            // Past the last filed cell the ray meets nothing more.
-            if ((stepC > 0 && c > this.c1) || (stepC < 0 && c < this.c0))
-                return;
-            if ((stepR > 0 && r > this.r1) || (stepR < 0 && r < this.r0))
-                return;
-            if (!stepC && (c < this.c0 || c > this.c1))
-                return;
-            if (!stepR && (r < this.r0 || r > this.r1))
-                return;
-        }
-    }
-    /**
-     * Segments whose bounds meet a box, each once, in {@link Blockers} order.
-     * @param x0 Box min x.
-     * @param y0 Box min y.
-     * @param x1 Box max x.
-     * @param y1 Box max y.
-     * @returns Their positions in {@link segs}.
-     */
-    near(x0, y0, x1, y1) {
-        const found = [];
-        this.stamp++;
-        this.cover(x0, y0, x1, y1, (key) => {
-            for (const i of this.cells.get(key) ?? []) {
-                if (this.seen[i] === this.stamp)
-                    continue;
-                this.seen[i] = this.stamp;
-                const seg = this.segs[i];
-                if (Math.max(seg[0], seg[2]) >= x0 &&
-                    Math.min(seg[0], seg[2]) <= x1 &&
-                    Math.max(seg[1], seg[3]) >= y0 &&
-                    Math.min(seg[1], seg[3]) <= y1)
-                    found.push(i);
-            }
-        });
-        return found.sort((a, b) => a - b);
-    }
-    /**
-     * Whether a segment crosses any blocker of one kind (exact `segmentsCross` on the candidates).
-     * @param seg The segment.
-     * @param from Blocker kind.
-     * @param except Destination whose own edges do not count.
-     * @returns True when one crosses it.
-     */
-    crosses(seg, from, except) {
-        return this.crossing(seg, from, except).length > 0;
-    }
-    /**
-     * The blockers of one kind a segment crosses (exact `segmentsCross` on the candidates).
-     * @param seg The segment.
-     * @param from Blocker kind.
-     * @param except Destination whose own edges do not count.
-     * @returns The blockers crossed.
-     */
-    crossing(seg, from, except) {
-        return this.near(Math.min(seg[0], seg[2]), Math.min(seg[1], seg[3]), Math.max(seg[0], seg[2]), Math.max(seg[1], seg[3]))
-            .filter((i) => this.from[i] === from &&
-            (except === undefined || this.owner[i] !== except) &&
-            segmentsCross(seg, this.segs[i]))
-            .map((i) => this.segs[i]);
-    }
-}
-/**
- * Walls and outlines whose bounds meet a box.
- * @param blockers The blockers.
- * @param box The box.
- * @returns Each segment with its owning destination; no owner for a wall.
- */
-export function blockersNear(blockers, box) {
-    const grid = blockerGrid(blockers);
-    const [x0, y0, x1, y1] = box;
-    return grid
-        .near(x0, y0, x1, y1)
-        .filter((i) => grid.from[i] !== BlockerKind.Gap)
-        .map((i) => grid.from[i] === BlockerKind.Solid
-        ? { seg: grid.segs[i], owner: grid.owner[i] }
-        : { seg: grid.segs[i] });
-}
-/** One grid per blockers object, built lazily. */
-const grids = new WeakMap();
-/**
- * The index of a blockers object, built once and kept with it.
- * @param blockers The blockers.
- * @returns Their index.
- */
-export function blockerGrid(blockers) {
-    let grid = grids.get(blockers);
-    if (!grid) {
-        grid = new SegmentGrid(blockers);
-        grids.set(blockers, grid);
-    }
-    return grid;
-}
-/**
- * Whether a segment crosses a wall, a closed doorway side or the outline of a destination nobody
- * walks through: the rule every network line keeps.
- * @param blockers The blockers.
- * @param seg The segment.
- * @returns True when it crosses one.
- */
-export function crossesBlocker(blockers, seg) {
-    const grid = blockerGrid(blockers);
-    return grid.crosses(seg, BlockerKind.Wall) || grid.crosses(seg, BlockerKind.Solid);
-}
-/**
- * What a run out of a destination may not cross, read once for the layer.
- * @param destinations Every destination on the layer.
- * @param walls The layer's wall segments.
- * @param doors The layer's doorways.
- * @param drawn The rest of each destination's drawing, by the destination's id.
- * @param walled Destinations entered through doorways: the walls they line stand in for them.
- * @param passes Wall spans an entrance's dock may cross, by the entrance's id.
- * @returns The blockers.
- */
-export function blockersOf(destinations, walls, doors, drawn = [], walled = new Set(), passes) {
-    return {
-        walls,
-        solid: [
-            ...destinations
-                .filter((d) => !d.crossable && d.polygon.length >= 3)
-                .map((d) => ({ id: d.id, edges: ringEdges(d.polygon) })),
-            ...drawn.map((block) => ({ id: block.id, edges: ringEdges(block.ring) })),
-        ],
-        gaps: doors.map((door) => door.gap),
-        walled,
-        ...(passes && { passes }),
-    };
-}
-/**
- * How far a ray runs before it meets a blocker, by exact intersection, and what it met.
- * @param ox Ray origin x.
- * @param oy Ray origin y.
- * @param nx Ray direction x.
- * @param ny Ray direction y.
- * @param ownId Destination the ray leaves.
- * @param own `'skip'` ignores its outline; `'ahead'` counts only the outline ahead of the start.
- * @param withGaps Whether a doorway gap stops the ray.
- * @param blockers What the ray may meet.
- * @returns The distance, or `Infinity` when the ray meets nothing.
- */
-export function freeRun(ox, oy, nx, ny, ownId, own, withGaps, blockers) {
-    let best = Infinity;
-    const hit = [0, 0];
-    // `from`: where hits start to count. A wall along the start face closes the ray; the own outline there
-    // is the face itself and does not.
-    const test = (seg, from) => {
-        if (!rayVsSegment(hit, ox, oy, nx, ny, seg[0], seg[1], seg[2], seg[3]))
-            return;
-        const [t, u] = hit;
-        if (u < -1e-9 || u > 1 + 1e-9 || t <= from)
-            return;
-        if (t < best)
-            best = Math.max(0, t);
-    };
-    const grid = blockerGrid(blockers);
-    // Cell by cell outward: a hit's segment is filed in the hit's cell, so once the best hit is nearer than
-    // the cell being left, no later cell holds a nearer one.
-    grid.alongRay(ox, oy, nx, ny, -2 * NODE_SNAP, (ids, leaves) => {
-        for (const i of ids) {
-            const seg = grid.segs[i];
-            const owner = grid.owner[i];
-            if (grid.from[i] === BlockerKind.Wall)
-                test(seg, -NODE_SNAP);
-            else if (grid.from[i] === BlockerKind.Gap) {
-                if (withGaps)
-                    test(seg, NODE_SNAP);
-            }
-            else if (owner !== ownId || own !== 'skip')
-                test(seg, owner === ownId ? NODE_SNAP : -NODE_SNAP);
-        }
-        return best < leaves - GRID_PAD;
-    });
-    return best;
-}

package/dist/lib/cell-array.d.ts

@@ -1,14 +0,0 @@
-/** The engine refused the memory a floor's raster needs: the floor is too large for this device. */
-export declare class CellsRefusedError extends Error {
-    constructor(length: number);
-}
-/**
- * A raster-sized typed array. An engine refuses a valid length only for want of memory, whatever its
- * message says, so any refusal of one throws {@link CellsRefusedError}; an invalid length is a bug and
- * its error passes through.
- * @param Ctor The typed array class.
- * @param length Its length, in cells.
- * @returns The zeroed array.
- */
-export declare function cellArray<T>(Ctor: new (length: number) => T, length: number): T;
-//# sourceMappingURL=cell-array.d.ts.map

package/dist/lib/cell-array.js

@@ -1,25 +0,0 @@
-/** The engine refused the memory a floor's raster needs: the floor is too large for this device. */
-export class CellsRefusedError extends Error {
-    constructor(length) {
-        super(`the engine refused a raster of ${length} cells`);
-        this.name = 'CellsRefusedError';
-    }
-}
-/**
- * A raster-sized typed array. An engine refuses a valid length only for want of memory, whatever its
- * message says, so any refusal of one throws {@link CellsRefusedError}; an invalid length is a bug and
- * its error passes through.
- * @param Ctor The typed array class.
- * @param length Its length, in cells.
- * @returns The zeroed array.
- */
-export function cellArray(Ctor, length) {
-    try {
-        return new Ctor(length);
-    }
-    catch (error) {
-        if (Number.isSafeInteger(length) && length >= 0)
-            throw new CellsRefusedError(length);
-        throw error;
-    }
-}

package/dist/lib/compile-layer.d.ts

@@ -1,41 +0,0 @@
-import type { NormalizeFacts } from './diagnostics.js';
-import type { BooleanOps } from './geom/boolean-ops.js';
-import type { RouteNetwork } from './graph-types.js';
-import type { SourceDestination, WayfindingLayerSource } from './types.js';
-import { type WalkableArea } from './walkable.js';
-/** One layer's stage artifacts. */
-interface CompiledLayer {
-    /** Globally unique layer id. */
-    readonly layer: string;
-    /** The destinations as the stages saw them, rings normalized and carved. */
-    readonly destinations: SourceDestination[];
-    /** Walkable area. */
-    readonly walkable: WalkableArea;
-    /** Route network. */
-    readonly network: RouteNetwork;
-    /** What normalization did to the drawing, for the diagnostics. */
-    readonly facts: NormalizeFacts;
-}
-/** Options of one layer's compile. */
-interface CompileLayerOptions {
-    /** A walkable area already built for this layer; the stage is skipped. */
-    readonly walkable?: WalkableArea;
-    /** Called as each stage finishes; `cached` when it was handed its artifact. */
-    readonly onStage?: (stage: 'walkable' | 'network', cached: boolean) => void;
-}
-/**
- * One layer's pipeline: walkable area, then route network.
- * @param source One layer's walls and destinations.
- * @param ops Polygon boolean backend.
- * @param options A ready walkable area and the stage callback.
- * @returns The layer's walkable area and route network.
- */
-export declare function compileLayer(source: WayfindingLayerSource, ops: BooleanOps, options?: CompileLayerOptions): CompiledLayer;
-/**
- * Destinations sorted by id, then outline, so input order does not change the network.
- * @param destinations The destinations as given.
- * @returns A sorted copy.
- */
-export declare function inCanonicalOrder(destinations: readonly SourceDestination[]): SourceDestination[];
-export {};
-//# sourceMappingURL=compile-layer.d.ts.map

package/dist/lib/compile-layer.js

@@ -1,241 +0,0 @@
-// One layer's pipeline: the destinations read as the stages see them — rings normalized, footprints
-// carved back to the walls, zones and blocking stands read crossable — then the walkable area and the
-// route network over it.
-import { blockersOf } from './blockers.js';
-import { doorOwners, doorwaySides, findDoorways } from './doorways.js';
-import { dockFor, standingBefore, stubLength, waysInto } from './entries.js';
-import { footprintOf } from './geom/footprint.js';
-import { cleanRing } from './geom/normalize.js';
-import { boundsOf, pointInRing, signedArea, vertexMean } from './geom/primitives.js';
-import { prepareWalls } from './geom/walls.js';
-import { NETWORK_SIZES } from './network-sizes.js';
-import { entranceOpenings } from './openings.js';
-import { buildSteinerNetwork } from './steiner-network.js';
-import { buildWalkableArea, carveFootprints, inBuilding, outerContoursOf, WALL_HALF_WIDTH, wallStripsOf, } from './walkable.js';
-/**
- * One layer's pipeline: walkable area, then route network.
- * @param source One layer's walls and destinations.
- * @param ops Polygon boolean backend.
- * @param options A ready walkable area and the stage callback.
- * @returns The layer's walkable area and route network.
- */
-export function compileLayer(source, ops, options) {
-    // Walls first: the building's outline is theirs alone. The walls are read and offset once and shared
-    // by every stage below.
-    const prepared = prepareWalls(source.walls);
-    const contours = options?.walkable ? undefined : outerContoursOf(prepared.runs);
-    const outline = options?.walkable?.outline ?? ops.union(contours ?? []);
-    // A destination with neither its middle nor a corner inside the building never reaches the network:
-    // it is reported off the floor without being traced, carved or entered.
-    const offFloor = (d) => {
-        const ring = cleanRing(d.dock ?? d.polygon);
-        return outline.length > 0 && ![vertexMean(ring), ...ring].some((p) => inBuilding(outline, p));
-    };
-    const sorted = inCanonicalOrder(source.destinations);
-    // Entrances go through the walls they stand across, or the nearest wall when they stand outside;
-    // the walls stay whole. An entrance that got an opening is on the floor.
-    const opened = entranceOpenings(prepared, outline, sorted, offFloor);
-    const openedIds = new Set(opened.openings.map((o) => o.id));
-    const outside = sorted.filter((d) => offFloor(d) && !openedIds.has(d.id));
-    const shapes = [];
-    const zones = [];
-    let sized;
-    // Normalize rings once so docking grows one stub per real face; a ring that normalizes below 3
-    // vertices stays raw, visible to diagnostics. `parts` become the footprint and are dropped from
-    // the artifacts.
-    const destinations = sorted
-        .filter((d) => !outside.includes(d))
-        .map((d) => {
-        const { parts, ...rest } = d;
-        const shape = parts?.length
-            ? footprintOf(parts, ops, rest.dock)
-            : { ring: null, drawn: [] };
-        const polygon = shape.ring ?? cleanRing(rest.polygon);
-        const dock = rest.dock ? cleanRing(rest.dock) : undefined;
-        const cleaned = dock && dock.length >= 3 ? { ...rest, dock } : rest;
-        const drawn = shape.drawn.length ? { ...cleaned, drawnShape: shape.drawn } : cleaned;
-        if (parts?.length && shape.how)
-            shapes.push({ id: d.id, how: shape.how, parts: parts.length });
-        return polygon.length >= 3 ? { ...drawn, polygon } : drawn;
-    })
-        .map((d, index, all) => {
-        sized ??= all.map(sizeOf);
-        if (d.crossable || !holdsAnother(sized[index], sized))
-            return d;
-        zones.push(d.id);
-        return { ...d, crossable: true };
-    });
-    // Footprints are carved back to their walls here, and every later stage sees the carved shape.
-    const shared = {
-        walls: prepared,
-        strips: wallStripsOf(ops, prepared.segments, WALL_HALF_WIDTH),
-        ...(contours && { contours }),
-    };
-    // Every piece of a solid destination is carved: footprints first, so carved rings pair back by
-    // position, then the rest of the drawing. Owners are positions, not ids: ids may repeat or be
-    // blank.
-    const solid = [];
-    const rings = [];
-    const owner = [];
-    destinations.forEach((d, index) => {
-        if (d.crossable)
-            return;
-        solid.push(index);
-        rings.push(d.polygon);
-        owner.push(index);
-    });
-    // A piece of the drawing another destination stands in is ground around it, not a block.
-    const holdsOther = (block, index) => destinations.some((other, k) => k !== index && other.polygon.length >= 3 && pointInRing(block, vertexMean(other.polygon)));
-    for (const index of solid)
-        for (const block of destinations[index].drawnShape ?? []) {
-            rings.push(block);
-            owner.push(index);
-        }
-    const { rings: obstacles, clipped } = carveFootprints(rings, shared.strips, ops);
-    // The rest of the drawing is input only; it stays off the artifacts, which are in plan units.
-    let next = 0;
-    const carved = destinations.map(({ drawnShape: _block, ...rest }) => rest.crossable ? rest : { ...rest, polygon: obstacles[next++] });
-    // The rest of each drawing blocks ways in.
-    const drawnOf = (index) => (destinations[index].drawnShape ?? [])
-        .filter((ring) => !holdsOther(ring, index))
-        .map((ring) => ({ id: destinations[index].id, ring }));
-    // Read on the carved outlines, as every later stage sees them. A destination named here stops
-    // being an obstacle: its ring leaves the floor, without re-carving.
-    const passable = crossableByStanding(carved, prepared, NETWORK_SIZES, solid.flatMap(drawnOf));
-    const open = carved.map((d, index) => (passable.has(index) ? { ...d, crossable: true } : d));
-    const standing = obstacles.filter((_, index) => !passable.has(owner[index]));
-    const walkable = options?.walkable ??
-        buildWalkableArea({ walls: source.walls, obstacles: standing }, ops, WALL_HALF_WIDTH, shared);
-    options?.onStage?.('walkable', options.walkable != null);
-    // Raw walls too: doorways and ways in use their exact geometry.
-    const drawnBlocks = solid.filter((index) => !passable.has(index)).flatMap(drawnOf);
-    const network = buildSteinerNetwork(walkable.rings, open, source.walls, prepared, drawnBlocks, opened.openings);
-    options?.onStage?.('network', false);
-    const off = outside.map(({ parts: _parts, ...d }) => d);
-    // An entrance outside that opened no wall keeps what the search found.
-    const noFloor = new Map(opened.unreached.map((u) => [u.id, u]));
-    const byEntrance = new Map();
-    for (const { id, at, by, distance } of opened.openings) {
-        const entry = byEntrance.get(id) ?? {
-            id,
-            by,
-            at: [],
-            ...(distance !== undefined && { distance }),
-        };
-        // A wall open to both sides is one place.
-        const seen = entry.at.some(([x, y]) => x === at[0] && y === at[1]);
-        byEntrance.set(id, seen ? entry : { ...entry, at: [...entry.at, at] });
-    }
-    const facts = {
-        wallEntries: prepared.entries,
-        shapes,
-        // Footprint rings only: a clipped auxiliary drawn block is not the footprint being cut back.
-        clipped: clipped
-            .slice(0, solid.length)
-            .flatMap((cut, index) => (cut ? [destinations[owner[index]].id] : [])),
-        crossable: [
-            ...zones.map((id) => ({ id, by: 'holds-another' })),
-            ...[...passable].map(([index, victims]) => ({
-                id: carved[index].id,
-                by: 'stands-before',
-                victims,
-            })),
-        ],
-        openings: [...byEntrance.values()],
-        entrancesUnopened: open.flatMap((d) => (d.entrance && !openedIds.has(d.id) ? [d.id] : [])),
-    };
-    return {
-        layer: source.layer,
-        destinations: [...open, ...off],
-        walkable,
-        network: {
-            ...network,
-            stats: {
-                ...network.stats,
-                unreached: [
-                    ...network.stats.unreached,
-                    ...off.map((d) => noFloor.get(d.id) ?? { id: d.id, reason: 'no-floor', outside: true }),
-                ],
-            },
-        },
-        facts,
-    };
-}
-/**
- * Destinations a route must cross because they stand in front of another destination's only way in.
- * Only when that destination has no way in at all, and the one in front is reachable itself.
- * @param destinations The layer's destinations, footprints already carved.
- * @param prepared The layer's walls as drawn, already read: the doorways are theirs.
- * @param cfg Network sizes.
- * @param drawn The rest of each destination's drawing, as the network will see it.
- * @returns The positions of the destinations to walk through, each with the ids it walled in.
- */
-function crossableByStanding(destinations, prepared, cfg, drawn) {
-    // Every gap in the walls, including ones a footprint stands across.
-    const doors = findDoorways(prepared);
-    const owners = doorOwners(doors, destinations, prepared.segments, cfg);
-    const blockers = blockersOf(destinations, [...prepared.segments, ...doorwaySides(doors, cfg)], doors, drawn);
-    // Usable as the network judges it: a person fits in front, and its stub docks lawfully.
-    const usable = (d, ways) => ways.some((way) => {
-        const run = stubLength(way, cfg);
-        return (way.depth >= cfg.clear &&
-            dockFor(d, way, [way.mx + way.nx * run, way.my + way.ny * run], blockers) !== null);
-    });
-    const ways = destinations.map((d) => waysInto(d, owners, blockers, cfg));
-    const reachable = destinations.map((d, index) => usable(d, ways[index]));
-    // A repeated id names none of its destinations (-1).
-    const at = new Map();
-    destinations.forEach((d, index) => at.set(d.id, at.has(d.id) ? -1 : index));
-    const passable = new Map();
-    for (const [index, victim] of destinations.entries()) {
-        if (victim.crossable || reachable[index])
-            continue;
-        // Whoever stands in the strip a person needs in front of a way in closed it.
-        for (const way of ways[index])
-            for (const id of standingBefore(way, victim.id, blockers, cfg.clear)) {
-                const who = at.get(id) ?? -1;
-                if (who < 0 || !reachable[who])
-                    continue;
-                const victims = passable.get(who) ?? [];
-                if (!victims.includes(victim.id))
-                    passable.set(who, [...victims, victim.id]);
-            }
-    }
-    return passable;
-}
-/**
- * Destinations sorted by id, then outline, so input order does not change the network.
- * @param destinations The destinations as given.
- * @returns A sorted copy.
- */
-export function inCanonicalOrder(destinations) {
-    const outline = (d) => JSON.stringify([d.polygon, d.parts ?? [], d.dock ?? []]);
-    const compare = (a, b) => (a < b ? -1 : a > b ? 1 : 0);
-    return [...destinations].sort((a, b) => compare(a.id, b.id) || compare(outline(a), outline(b)));
-}
-function sizeOf({ polygon }) {
-    return {
-        polygon,
-        area: polygon.length < 3 ? 0 : Math.abs(signedArea(polygon)),
-        box: boundsOf(polygon),
-        middle: polygon.length < 3 ? [NaN, NaN] : vertexMean(polygon),
-    };
-}
-/**
- * Whether a smaller destination's centroid lies inside this one (a pavilion, a hall of stands).
- * Such a destination is a zone people walk in, not an obstacle.
- * @param d The destination.
- * @param all Every destination on the layer.
- * @returns True when `d` holds another destination.
- */
-function holdsAnother(d, all) {
-    if (d.polygon.length < 3)
-        return false;
-    const [x0, y0, x1, y1] = d.box;
-    return all.some((other) => {
-        if (other === d || other.polygon.length < 3 || other.area >= d.area)
-            return false;
-        const [x, y] = other.middle;
-        return x >= x0 && x <= x1 && y >= y0 && y <= y1 && pointInRing(d.polygon, other.middle);
-    });
-}