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

package/dist/lib/geom/normalize.js

@@ -1,118 +0,0 @@
-import { POINT_EPS } from './point-key.js';
-import { pointSegmentDistance } from './primitives.js';
-/**
- * Distance between two vertices.
- * @param a One vertex.
- * @param b The other.
- * @returns The distance.
- */
-function gap(a, b) {
-    return Math.hypot(a[0] - b[0], a[1] - b[1]);
-}
-/**
- * The step parity that carries the repeated joint vertices, or `-1` for a plain polyline.
- * @param verts Raw vertices.
- * @param eps Coincidence tolerance.
- * @returns `0`, `1`, or `-1`.
- */
-function jointParity(verts, eps) {
-    const glued = [0, 0];
-    const total = [0, 0];
-    for (let k = 0; k + 1 < verts.length; k++) {
-        total[k % 2]++;
-        if (gap(verts[k], verts[k + 1]) <= eps)
-            glued[k % 2]++;
-    }
-    // The parity glued more often, by share: a vertex written three times glues both parities once, and
-    // only the joints' parity is glued at every step.
-    const parity = glued[0] * total[1] >= glued[1] * total[0] ? 0 : 1;
-    // The joint parity is glued at least half the time; otherwise every step is a real segment.
-    return glued[parity] * 2 >= total[parity] && glued[parity] > 0 ? parity : -1;
-}
-/**
- * Dedups a run's vertices and detects whether it closes.
- * @param verts Raw vertices.
- * @param eps Merge tolerance.
- * @returns The run, without an explicit closing vertex.
- */
-function cleanRun(verts, eps) {
-    const points = [];
-    for (const [x, y] of verts) {
-        const last = points[points.length - 1];
-        if (last && gap([x, y], last) <= eps)
-            continue;
-        points.push([x, y]);
-    }
-    const closed = points.length > 2 && gap(points[0], points[points.length - 1]) <= eps;
-    if (closed)
-        points.pop();
-    return { points, closed };
-}
-/**
- * Splits a raw `walls` entry into the continuous runs it describes.
- *
- * The export stores one segment per vertex pair, joined by repeating the shared vertex; where a pair does
- * not touch the next, a new run starts elsewhere. Read as one polyline, each such gap would become a
- * phantom wall. The joint parity is read off the entry, since exports double from either vertex.
- * @param flat Flat `[x0, y0, x1, y1, …]` coordinates.
- * @param eps Merge tolerance for coincident vertices.
- * @returns The deduplicated runs; runs of fewer than two vertices are dropped.
- */
-export function cleanPolylineRuns(flat, eps = POINT_EPS) {
-    const verts = [];
-    for (let i = 0; i + 1 < flat.length; i += 2)
-        verts.push([flat[i], flat[i + 1]]);
-    if (verts.length < 2)
-        return [];
-    const joint = jointParity(verts, eps);
-    const runs = [];
-    let start = 0;
-    for (let k = 0; k + 1 < verts.length; k++) {
-        if (k % 2 !== joint || gap(verts[k], verts[k + 1]) <= eps)
-            continue;
-        runs.push(cleanRun(verts.slice(start, k + 1), eps));
-        start = k + 1;
-    }
-    runs.push(cleanRun(verts.slice(start), eps));
-    return runs.filter((run) => run.points.length >= 2);
-}
-/**
- * Normalizes a ring: drops coincident vertices (the closing one included) and vertices within `eps` of
- * the segment between their neighbors. Every surviving vertex splits a face, and each face grows a stub.
- * @param ring The ring, open or explicitly closed.
- * @param eps Tolerance for coincidence and collinearity.
- * @returns The ring, implicitly closed.
- */
-export function cleanRing(ring, eps = POINT_EPS) {
-    const pts = [];
-    for (const [x, y] of ring) {
-        const last = pts[pts.length - 1];
-        if (last && gap([x, y], last) <= eps)
-            continue;
-        pts.push([x, y]);
-    }
-    while (pts.length > 1) {
-        const a = pts[0];
-        const b = pts[pts.length - 1];
-        if (gap(a, b) > eps)
-            break;
-        pts.pop();
-    }
-    // Removing one vertex can expose the next, so sweep until stable.
-    let changed = true;
-    while (changed && pts.length > 3) {
-        changed = false;
-        for (let i = 0; i < pts.length && pts.length > 3; i++) {
-            const n = pts.length;
-            const prev = pts[(i + n - 1) % n];
-            const next = pts[(i + 1) % n];
-            const [x, y] = pts[i];
-            if (pointSegmentDistance(x, y, prev[0], prev[1], next[0], next[1]) > eps)
-                continue;
-            pts.splice(i, 1);
-            changed = true;
-            i--;
-        }
-    }
-    return pts;
-}

package/dist/lib/geom/point-key.d.ts

@@ -1,16 +0,0 @@
-/** The resolution the route network tells points apart by, in meters. */
-export declare const POINT_EPS = 0.01;
-/**
- * One coordinate on the centimeter grid.
- * @param v Coordinate in meters.
- * @returns The coordinate rounded to the centimeter.
- */
-export declare const snapCm: (v: number) => number;
-/**
- * A point's key throughout the compiler: its centimeter cell.
- * @param x Point x in meters.
- * @param y Point y in meters.
- * @returns The key.
- */
-export declare const pointKey: (x: number, y: number) => string;
-//# sourceMappingURL=point-key.d.ts.map

package/dist/lib/geom/point-key.js

@@ -1,15 +0,0 @@
-/** The resolution the route network tells points apart by, in meters. */
-export const POINT_EPS = 0.01;
-/**
- * One coordinate on the centimeter grid.
- * @param v Coordinate in meters.
- * @returns The coordinate rounded to the centimeter.
- */
-export const snapCm = (v) => Math.round(v * 100) / 100;
-/**
- * A point's key throughout the compiler: its centimeter cell.
- * @param x Point x in meters.
- * @param y Point y in meters.
- * @returns The key.
- */
-export const pointKey = (x, y) => `${Math.round(x * 100)}:${Math.round(y * 100)}`;

package/dist/lib/geom/primitives.d.ts

@@ -1,105 +0,0 @@
-import type { Box, Ring, Segment, Vec2 } from './types.js';
-/**
- * Signed area of a ring (shoelace).
- * @param ring The ring to measure.
- * @returns The area, positive when the ring winds counter-clockwise.
- */
-export declare function signedArea(ring: Ring): number;
-/**
- * The ring wound positive, as the boolean backend's NonZero fill needs.
- * @param ring The ring.
- * @returns The ring itself when already positive, else a reversed copy.
- */
-export declare function wound(ring: Ring): Ring;
-/**
- * The outer rings of a boolean result, told from its holes by their winding: outers wind like the
- * largest ring, holes the other way.
- * @param rings Outer rings and holes, as the boolean backend returns them.
- * @returns The outer rings, in input order.
- */
-export declare function outerRingsOf(rings: readonly Ring[]): Ring[];
-/**
- * Even-odd ray-cast point-in-ring test. A point on the boundary may land on either side.
- * @param ring The ring to test against.
- * @param point The point to locate.
- * @returns True when the ring contains the point.
- */
-export declare function pointInRing(ring: Ring, point: Vec2): boolean;
-/**
- * Axis-aligned bounds of a set of points.
- * @param points The points.
- * @returns `[minX, minY, maxX, maxY]`; `[Infinity, Infinity, -Infinity, -Infinity]` for no points.
- */
-export declare function boundsOf(points: Iterable<Vec2>): Box;
-/**
- * Whether two bounds overlap, touching included.
- * @param a One box.
- * @param b The other.
- * @returns True when they overlap.
- */
-export declare function boxesOverlap(a: Readonly<Box>, b: Readonly<Box>): boolean;
-/**
- * Mean of a ring's vertices — inside it for a convex ring.
- * @param ring The ring.
- * @returns The mean point.
- */
-export declare function vertexMean(ring: Ring): Vec2;
-/**
- * Where along a segment a point projects.
- * @param px Point x.
- * @param py Point y.
- * @param x0 Segment start x.
- * @param y0 Segment start y.
- * @param x1 Segment end x.
- * @param y1 Segment end y.
- * @returns The share of the segment's length from its start, clamped to [0, 1]; 0 for a zero-length segment.
- */
-export declare function segmentParam(px: number, py: number, x0: number, y0: number, x1: number, y1: number): number;
-/**
- * Distance from a point to a segment.
- * @param px Point x.
- * @param py Point y.
- * @param x0 Segment start x.
- * @param y0 Segment start y.
- * @param x1 Segment end x.
- * @param y1 Segment end y.
- * @returns The distance to the nearest point of the segment.
- */
-export declare function pointSegmentDistance(px: number, py: number, x0: number, y0: number, x1: number, y1: number): number;
-/**
- * A ray `o + d·t` against the line through a segment `a + e·u`; the caller bounds `t` and `u`.
- * @param out Receives `[t, u]` when the lines are not parallel.
- * @param ox Ray origin x.
- * @param oy Ray origin y.
- * @param dx Ray direction x.
- * @param dy Ray direction y.
- * @param x0 Segment start x.
- * @param y0 Segment start y.
- * @param x1 Segment end x.
- * @param y1 Segment end y.
- * @returns False when the ray runs parallel to the segment.
- */
-export declare function rayVsSegment(out: [number, number], ox: number, oy: number, dx: number, dy: number, x0: number, y0: number, x1: number, y1: number): boolean;
-/**
- * Whether two segments properly cross; touching or collinear is not a crossing.
- * @param seg One segment.
- * @param blocker The other.
- * @returns True when each has the other's ends strictly on opposite sides.
- */
-export declare function segmentsCross(seg: Segment, blocker: Segment): boolean;
-/**
- * A ring's edges as segments.
- * @param ring The ring.
- * @returns One segment per edge, closing edge included.
- */
-export declare function ringEdges(ring: Ring): Segment[];
-/**
- * Whether a point lies on a ring's outline.
- * @param ring The ring.
- * @param x Point x.
- * @param y Point y.
- * @param eps Tolerance.
- * @returns True when some edge is within `eps`.
- */
-export declare function onOutline(ring: Ring, x: number, y: number, eps: number): boolean;
-//# sourceMappingURL=primitives.d.ts.map

package/dist/lib/geom/primitives.js

@@ -1,184 +0,0 @@
-// Planar primitives shared by the stages, on `[x, y]` tuples.
-/**
- * Signed area of a ring (shoelace).
- * @param ring The ring to measure.
- * @returns The area, positive when the ring winds counter-clockwise.
- */
-export function signedArea(ring) {
-    let sum = 0;
-    for (let i = 0; i < ring.length; i++) {
-        const [x1, y1] = ring[i];
-        const [x2, y2] = ring[(i + 1) % ring.length];
-        sum += x1 * y2 - x2 * y1;
-    }
-    return sum / 2;
-}
-/**
- * The ring wound positive, as the boolean backend's NonZero fill needs.
- * @param ring The ring.
- * @returns The ring itself when already positive, else a reversed copy.
- */
-export function wound(ring) {
-    return signedArea(ring) < 0 ? [...ring].reverse() : ring;
-}
-/**
- * The outer rings of a boolean result, told from its holes by their winding: outers wind like the
- * largest ring, holes the other way.
- * @param rings Outer rings and holes, as the boolean backend returns them.
- * @returns The outer rings, in input order.
- */
-export function outerRingsOf(rings) {
-    if (!rings.length)
-        return [];
-    const areas = rings.map(signedArea);
-    const outer = Math.sign(areas.reduce((a, b) => (Math.abs(b) > Math.abs(a) ? b : a)));
-    return rings.filter((_, i) => Math.sign(areas[i]) === outer);
-}
-/**
- * Even-odd ray-cast point-in-ring test. A point on the boundary may land on either side.
- * @param ring The ring to test against.
- * @param point The point to locate.
- * @returns True when the ring contains the point.
- */
-export function pointInRing(ring, point) {
-    const [x, y] = point;
-    let inside = false;
-    for (let i = 0, j = ring.length - 1; i < ring.length; j = i++) {
-        const [xi, yi] = ring[i];
-        const [xj, yj] = ring[j];
-        if (yi > y !== yj > y && x < ((xj - xi) * (y - yi)) / (yj - yi) + xi)
-            inside = !inside;
-    }
-    return inside;
-}
-/**
- * Axis-aligned bounds of a set of points.
- * @param points The points.
- * @returns `[minX, minY, maxX, maxY]`; `[Infinity, Infinity, -Infinity, -Infinity]` for no points.
- */
-export function boundsOf(points) {
-    let minX = Infinity;
-    let minY = Infinity;
-    let maxX = -Infinity;
-    let maxY = -Infinity;
-    for (const [x, y] of points) {
-        minX = Math.min(minX, x);
-        minY = Math.min(minY, y);
-        maxX = Math.max(maxX, x);
-        maxY = Math.max(maxY, y);
-    }
-    return [minX, minY, maxX, maxY];
-}
-/**
- * Whether two bounds overlap, touching included.
- * @param a One box.
- * @param b The other.
- * @returns True when they overlap.
- */
-export function boxesOverlap(a, b) {
-    return a[0] <= b[2] && b[0] <= a[2] && a[1] <= b[3] && b[1] <= a[3];
-}
-/**
- * Mean of a ring's vertices — inside it for a convex ring.
- * @param ring The ring.
- * @returns The mean point.
- */
-export function vertexMean(ring) {
-    let cx = 0;
-    let cy = 0;
-    for (const [x, y] of ring) {
-        cx += x / ring.length;
-        cy += y / ring.length;
-    }
-    return [cx, cy];
-}
-/**
- * Where along a segment a point projects.
- * @param px Point x.
- * @param py Point y.
- * @param x0 Segment start x.
- * @param y0 Segment start y.
- * @param x1 Segment end x.
- * @param y1 Segment end y.
- * @returns The share of the segment's length from its start, clamped to [0, 1]; 0 for a zero-length segment.
- */
-export function segmentParam(px, py, x0, y0, x1, y1) {
-    const dx = x1 - x0;
-    const dy = y1 - y0;
-    const ll = dx * dx + dy * dy;
-    return ll ? Math.max(0, Math.min(1, ((px - x0) * dx + (py - y0) * dy) / ll)) : 0;
-}
-/**
- * Distance from a point to a segment.
- * @param px Point x.
- * @param py Point y.
- * @param x0 Segment start x.
- * @param y0 Segment start y.
- * @param x1 Segment end x.
- * @param y1 Segment end y.
- * @returns The distance to the nearest point of the segment.
- */
-export function pointSegmentDistance(px, py, x0, y0, x1, y1) {
-    const t = segmentParam(px, py, x0, y0, x1, y1);
-    return Math.hypot(x0 + t * (x1 - x0) - px, y0 + t * (y1 - y0) - py);
-}
-/**
- * A ray `o + d·t` against the line through a segment `a + e·u`; the caller bounds `t` and `u`.
- * @param out Receives `[t, u]` when the lines are not parallel.
- * @param ox Ray origin x.
- * @param oy Ray origin y.
- * @param dx Ray direction x.
- * @param dy Ray direction y.
- * @param x0 Segment start x.
- * @param y0 Segment start y.
- * @param x1 Segment end x.
- * @param y1 Segment end y.
- * @returns False when the ray runs parallel to the segment.
- */
-export function rayVsSegment(out, ox, oy, dx, dy, x0, y0, x1, y1) {
-    const ex = x1 - x0;
-    const ey = y1 - y0;
-    const det = dx * ey - dy * ex;
-    if (Math.abs(det) < 1e-9)
-        return false;
-    out[0] = ((x0 - ox) * ey - (y0 - oy) * ex) / det;
-    out[1] = ((x0 - ox) * dy - (y0 - oy) * dx) / det;
-    return true;
-}
-/**
- * Whether two segments properly cross; touching or collinear is not a crossing.
- * @param seg One segment.
- * @param blocker The other.
- * @returns True when each has the other's ends strictly on opposite sides.
- */
-export function segmentsCross(seg, blocker) {
-    const side = (ax, ay, bx, by, cx, cy) => Math.sign((bx - ax) * (cy - ay) - (by - ay) * (cx - ax));
-    return (side(seg[0], seg[1], seg[2], seg[3], blocker[0], blocker[1]) *
-        side(seg[0], seg[1], seg[2], seg[3], blocker[2], blocker[3]) <
-        0 &&
-        side(blocker[0], blocker[1], blocker[2], blocker[3], seg[0], seg[1]) *
-            side(blocker[0], blocker[1], blocker[2], blocker[3], seg[2], seg[3]) <
-            0);
-}
-/**
- * A ring's edges as segments.
- * @param ring The ring.
- * @returns One segment per edge, closing edge included.
- */
-export function ringEdges(ring) {
-    return ring.map((a, i) => {
-        const b = ring[(i + 1) % ring.length];
-        return [a[0], a[1], b[0], b[1]];
-    });
-}
-/**
- * Whether a point lies on a ring's outline.
- * @param ring The ring.
- * @param x Point x.
- * @param y Point y.
- * @param eps Tolerance.
- * @returns True when some edge is within `eps`.
- */
-export function onOutline(ring, x, y, eps) {
-    return ringEdges(ring).some((edge) => pointSegmentDistance(x, y, ...edge) <= eps);
-}

package/dist/lib/geom/split-crossings.d.ts

@@ -1,14 +0,0 @@
-import type { Segment, Vec2 } from './types.js';
-/**
- * Cuts segments wherever they meet away from their ends, so every meeting is a shared vertex.
- *
- * Near ends are welded first; each meeting point is then computed once and cut into every segment it lies
- * inside, so both sides end on identical coordinates. Swept by left edge.
- * @param input The segments, in meters.
- * @param eps Tolerance for lying on a segment or at its end.
- * @param fixed Vertices found elsewhere by exact coordinates; near ends join them, not the reverse.
- * @param moved Receives each fixed vertex that merged into another, by key.
- * @returns The distinct pieces.
- */
-export declare function splitCrossings(input: readonly Segment[], eps?: number, fixed?: readonly Vec2[], moved?: Map<string, Vec2>): Segment[];
-//# sourceMappingURL=split-crossings.d.ts.map

package/dist/lib/geom/split-crossings.js

@@ -1,171 +0,0 @@
-import { POINT_EPS, pointKey } from './point-key.js';
-import { pointSegmentDistance, segmentParam } from './primitives.js';
-const minX = (s) => Math.min(s[0], s[2]);
-/**
- * Distance from a point to a segment.
- * @param s The segment.
- * @param p The point.
- * @returns The distance.
- */
-function distanceTo(s, p) {
-    return pointSegmentDistance(p[0], p[1], s[0], s[1], s[2], s[3]);
-}
-/**
- * Whether a point lies on a segment clear of both its ends.
- * @param s The segment.
- * @param p The point.
- * @param eps Tolerance.
- * @returns True for a point the segment has to be cut at.
- */
-function inside(s, p, eps) {
-    // Within `eps` of an end is that end, as in the weld.
-    return (distanceTo(s, p) < eps &&
-        Math.hypot(p[0] - s[0], p[1] - s[1]) >= eps &&
-        Math.hypot(p[0] - s[2], p[1] - s[3]) >= eps);
-}
-/**
- * Where two segments meet: an end of one on the other, and their crossing. A crossing within `eps` of an
- * end snaps to that end, so both sides cut at an existing vertex.
- * @param a One segment.
- * @param b The other.
- * @param eps Tolerance.
- * @returns Candidate cut points.
- */
-function meetings(a, b, eps) {
-    const ends = [
-        [a[0], a[1]],
-        [a[2], a[3]],
-        [b[0], b[1]],
-        [b[2], b[3]],
-    ];
-    const points = ends.filter((end, index) => distanceTo(index < 2 ? b : a, end) < eps);
-    const rx = a[2] - a[0];
-    const ry = a[3] - a[1];
-    const sx = b[2] - b[0];
-    const sy = b[3] - b[1];
-    const denom = rx * sy - ry * sx;
-    if (Math.abs(denom) < 1e-12)
-        return points;
-    const qx = b[0] - a[0];
-    const qy = b[1] - a[1];
-    const t = (qx * sy - qy * sx) / denom;
-    const u = (qx * ry - qy * rx) / denom;
-    if (t <= 0 || t >= 1 || u <= 0 || u >= 1)
-        return points;
-    const cross = [+(a[0] + t * rx).toFixed(2), +(a[1] + t * ry).toFixed(2)];
-    const nearest = ends.reduce((p, q) => Math.hypot(q[0] - cross[0], q[1] - cross[1]) < Math.hypot(p[0] - cross[0], p[1] - cross[1])
-        ? q
-        : p);
-    points.push(Math.hypot(nearest[0] - cross[0], nearest[1] - cross[1]) < eps ? nearest : cross);
-    return points;
-}
-/**
- * Joins ends closer than `eps` into one vertex: a fixed point if one is near, else the first end met.
- * Fixed points closer than `eps` merge into the first of them.
- * @param segments The segments.
- * @param eps Join distance.
- * @param fixed Points that never move.
- * @param moved Receives each fixed point that merged into another, by key.
- * @returns The welded segments, degenerate ones dropped.
- */
-function weldEnds(segments, eps, fixed, moved) {
-    const buckets = new Map();
-    const cell = (v) => Math.floor(v / eps);
-    const register = (point) => {
-        const key = `${cell(point[0])}:${cell(point[1])}`;
-        const bucket = buckets.get(key) ?? [];
-        bucket.push(point);
-        buckets.set(key, bucket);
-        return point;
-    };
-    const near = (x, y) => {
-        const cx = cell(x);
-        const cy = cell(y);
-        let best = null;
-        let bestDistance = eps;
-        for (let dx = -1; dx <= 1; dx++)
-            for (let dy = -1; dy <= 1; dy++)
-                for (const known of buckets.get(`${cx + dx}:${cy + dy}`) ?? []) {
-                    const distance = Math.hypot(known[0] - x, known[1] - y);
-                    if (distance < bestDistance) {
-                        best = known;
-                        bestDistance = distance;
-                    }
-                }
-        return best;
-    };
-    const weld = (x, y) => near(x, y) ?? register([x, y]);
-    for (const point of fixed) {
-        const joined = near(point[0], point[1]);
-        if (!joined)
-            register(point);
-        else if (joined[0] !== point[0] || joined[1] !== point[1])
-            moved?.set(pointKey(point[0], point[1]), joined);
-    }
-    const welded = [];
-    for (const s of segments) {
-        const from = weld(s[0], s[1]);
-        const to = weld(s[2], s[3]);
-        if (from !== to)
-            welded.push([from[0], from[1], to[0], to[1]]);
-    }
-    return welded;
-}
-/**
- * Cuts segments wherever they meet away from their ends, so every meeting is a shared vertex.
- *
- * Near ends are welded first; each meeting point is then computed once and cut into every segment it lies
- * inside, so both sides end on identical coordinates. Swept by left edge.
- * @param input The segments, in meters.
- * @param eps Tolerance for lying on a segment or at its end.
- * @param fixed Vertices found elsewhere by exact coordinates; near ends join them, not the reverse.
- * @param moved Receives each fixed vertex that merged into another, by key.
- * @returns The distinct pieces.
- */
-export function splitCrossings(input, eps = POINT_EPS, fixed = [], moved) {
-    const segments = weldEnds(input, eps, fixed, moved);
-    const cuts = segments.map(() => []);
-    const order = segments.map((_, i) => i).sort((i, j) => minX(segments[i]) - minX(segments[j]));
-    for (let oi = 0; oi < order.length; oi++) {
-        const a = segments[order[oi]];
-        const right = Math.max(a[0], a[2]) + eps;
-        const top = Math.max(a[1], a[3]) + eps;
-        const bottom = Math.min(a[1], a[3]) - eps;
-        for (let oj = oi + 1; oj < order.length; oj++) {
-            const b = segments[order[oj]];
-            if (minX(b) > right)
-                break;
-            if (Math.min(b[1], b[3]) > top || Math.max(b[1], b[3]) < bottom)
-                continue;
-            for (const point of meetings(a, b, eps)) {
-                if (inside(a, point, eps))
-                    cuts[order[oi]].push(point);
-                if (inside(b, point, eps))
-                    cuts[order[oj]].push(point);
-            }
-        }
-    }
-    const pieces = [];
-    const seen = new Set();
-    const add = (p, q) => {
-        const from = pointKey(p[0], p[1]);
-        const to = pointKey(q[0], q[1]);
-        const key = from < to ? `${from}|${to}` : `${to}|${from}`;
-        if (from === to || seen.has(key))
-            return;
-        seen.add(key);
-        pieces.push([p[0], p[1], q[0], q[1]]);
-    };
-    segments.forEach((s, i) => {
-        const along = cuts[i]
-            .map((point) => ({ point, t: segmentParam(point[0], point[1], s[0], s[1], s[2], s[3]) }))
-            .sort((p, q) => p.t - q.t);
-        let from = [s[0], s[1]];
-        for (const { point } of along) {
-            add(from, point);
-            from = point;
-        }
-        add(from, [s[2], s[3]]);
-    });
-    return pieces;
-}

package/dist/lib/geom/types.d.ts

@@ -1,9 +0,0 @@
-/** A point as an `[x, y]` tuple, which keeps the hot geometry loops allocation-light. */
-export type Vec2 = readonly [number, number];
-/** A polygon ring, implicitly closed (the first vertex is not repeated). */
-export type Ring = readonly Vec2[];
-/** A line segment as `[x0, y0, x1, y1]`. */
-export type Segment = [number, number, number, number];
-/** Axis-aligned bounds as `[minX, minY, maxX, maxY]`. */
-export type Box = [number, number, number, number];
-//# sourceMappingURL=types.d.ts.map

package/dist/lib/geom/types.js

@@ -1 +0,0 @@
-export {};

package/dist/lib/geom/walls.d.ts

@@ -1,31 +0,0 @@
-import { type WallLine } from './normalize.js';
-import type { Segment } from './types.js';
-/**
- * A raw `walls` entry the cleaning changed: it split into runs, cleaned to nothing (`runs === 0`
- * with something drawn), or held an odd trailing coordinate.
- */
-export interface WallEntryFact {
-    /** Index of the entry in the raw `walls` array. */
-    readonly entry: number;
-    /** How many continuous runs the entry split into; 0 when it cleaned away whole. */
-    readonly runs: number;
-    /** True when the entry's flat array holds an odd coordinate count, so the last number is dropped. */
-    readonly oddTail: boolean;
-}
-/** A layer's walls, read once: the cleaned runs and their segments. */
-export interface PreparedWalls {
-    /** All runs, each in canonical direction, sorted. */
-    readonly runs: readonly WallLine[];
-    /** One segment per wall piece (closing pieces included), in run order. */
-    readonly segments: readonly Segment[];
-    /** The entries the cleaning changed, in entry order. */
-    readonly entries: readonly WallEntryFact[];
-}
-/**
- * Reads a layer's raw walls once for every stage. Runs are canonicalized and sorted, so wall order and
- * drawing direction do not change the network.
- * @param walls Raw walls as flat `[x0, y0, …]` runs.
- * @returns The runs and their segments.
- */
-export declare function prepareWalls(walls: readonly (readonly number[])[]): PreparedWalls;
-//# sourceMappingURL=walls.d.ts.map