@pascal-app/core 1.0.4 → 1.0.6

package/dist/lib/absorb-wall-separators.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"absorb-wall-separators.d.ts","sourceRoot":"","sources":["../../src/lib/absorb-wall-separators.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAA;AAE/D,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmE5F"}
+{"version":3,"file":"absorb-wall-separators.d.ts","sourceRoot":"","sources":["../../src/lib/absorb-wall-separators.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAA;AAE/D,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmE5F"}

package/dist/lib/angle-accumulator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"angle-accumulator.d.ts","sourceRoot":"","sources":["../../src/lib/angle-accumulator.ts"],"names":[],"mappings":"AAAA,2EAA2E;AAC3E,wBAAgB,sBAAsB,CAAC,YAAY,EAAE,MAAM,IAGjD,OAAO,MAAM,YAOtB"}
+{"version":3,"file":"angle-accumulator.d.ts","sourceRoot":"","sources":["../../src/lib/angle-accumulator.ts"],"names":[],"mappings":"AAAA,2EAA2E;AAC3E,wBAAgB,sBAAsB,CAAC,YAAY,EAAE,MAAM,WAG1C,MAAM,YAOtB"}

package/dist/lib/artifact-store.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"artifact-store.d.ts","sourceRoot":"","sources":["../../src/lib/artifact-store.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,6BAA6B,CAAA;AAE3E;;;;;GAKG;AAEH,eAAO,MAAM,mBAAmB,gBAAgB,CAAA;AAEhD,MAAM,MAAM,aAAa,GAAG;IAC1B,sFAAsF;IACtF,GAAG,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,MAAM,GAAG,IAAI,CAAA;IACtC,gGAAgG;IAChG,GAAG,EAAE,CACH,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,WAAW,GAAG,UAAU,EAC/B,QAAQ,EAAE,MAAM,EAChB,OAAO,CAAC,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,wBAAwB,CAAA;KAAE,KAC7D,OAAO,CAAC,MAAM,CAAC,CAAA;IACpB,2GAA2G;IAC3G,IAAI,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAA;IAChD;;;;OAIG;IACH,QAAQ,CAAC,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,OAAO,CAAC,MAAM,EAAE,CAAC,CAAA;CACvE,CAAA;AAsBD,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,aAAa,GAAG,IAAI,GAAG,IAAI,CAEvE;AAED,wBAAgB,gBAAgB,IAAI,aAAa,CAEhD;AAED,eAAO,MAAM,WAAW,GAAI,QAAQ,MAAM,WAAsC,CAAA;AAEhF,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAIvD;AAED,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAG7D"}
+{"version":3,"file":"artifact-store.d.ts","sourceRoot":"","sources":["../../src/lib/artifact-store.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,6BAA6B,CAAA;AAE3E;;;;;GAKG;AAEH,eAAO,MAAM,mBAAmB,gBAAgB,CAAA;AAEhD,MAAM,MAAM,aAAa,GAAG;IAC1B,sFAAsF;IACtF,GAAG,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,MAAM,GAAG,IAAI,CAAA;IACtC,gGAAgG;IAChG,GAAG,EAAE,CACH,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,WAAW,GAAG,UAAU,EAC/B,QAAQ,EAAE,MAAM,EAChB,OAAO,CAAC,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,wBAAwB,CAAA;KAAE,KAC7D,OAAO,CAAC,MAAM,CAAC,CAAA;IACpB,2GAA2G;IAC3G,IAAI,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAA;IAChD;;;;OAIG;IACH,QAAQ,CAAC,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,OAAO,CAAC,MAAM,EAAE,CAAC,CAAA;CACvE,CAAA;AAsBD,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,aAAa,GAAG,IAAI,GAAG,IAAI,CAEvE;AAED,wBAAgB,gBAAgB,IAAI,aAAa,CAEhD;AAED,eAAO,MAAM,WAAW,WAAY,MAAM,WAAsC,CAAA;AAEhF,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAIvD;AAED,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAG7D"}

package/dist/lib/below-grade-footprints.d.ts

@@ -0,0 +1,65 @@
+import type { AnyNode, AnyNodeId } from '../schema/index.js';
+import { type Point2D } from './polygon-union.js';
+/**
+ * Where the ground meets the levels below grade, in the site's plan: each such level's floor slabs
+ * placed where its building stands and joined into outlines, the levels' together as one set (a
+ * deeper level wider than the one over it, or under part of it, gives one outline, not overlapping
+ * ones). The 3D view cuts its hole in the ground and draws its grade ring along them while the
+ * ground is veiled. An automatic floor follows the walls' centrelines, so an outline runs half a
+ * wall inside the outer faces. A level only partly below grade (a walk-out on a hillside) gives
+ * the part of its floor the ground stands over by more than {@link BELOW_GRADE_TOLERANCE}, the
+ * edge following the slope; fully buried levels give their whole floor.
+ *
+ * With `shownLevelId`, only what the level display needs open over that level: the level itself and
+ * the levels between it and grade (the ones the display hides above it: `level` index at or over
+ * its own, in every building, as the display decides from the index alone), the levels the author
+ * has hidden left out. The levels deeper than the one shown stay under the ground. Without it,
+ * every level below grade.
+ */
+export declare function belowGradeFootprints(nodes: Record<AnyNodeId, AnyNode>, shownLevelId?: string | null): Point2D[][];
+/**
+ * The part of the ground that lies over the house itself: what is below grade under the footprint
+ * of the levels above it, in the site's plan. The house covers it, so the ground can stand open
+ * there whatever level is shown: from outside nothing changes (the storeys are over it), and the
+ * stairwells and floor openings of the stacked view, and the walkthrough on a stair, meet the
+ * basement and not a sheet of ground across it. A below-grade level reaching out under the garden
+ * gives only the part the house stands over; the rest stays closed, no pit in the garden.
+ *
+ * Per building, a level below grade is covered by the floor slabs of the visible levels over it
+ * (`level` index above its own) that are not themselves fully buried: the ones at grade, and the
+ * part of a floor only partly below grade that stands out of the hill. A hidden level covers
+ * nothing and is covered by nothing. Of a level only partly below grade, only the part the ground
+ * stands over is open. A slab's own openings do not count: the stairwell is where the ground
+ * should be open.
+ *
+ * Outlines with an inner outline (a courtyard the house wraps round) are left out: the ground
+ * cannot be cut around an island of itself, and closed is the safe side.
+ */
+export declare function coveredBelowGradeFootprints(nodes: Record<AnyNodeId, AnyNode>): Point2D[][];
+/**
+ * How deep the pit under the hole goes: the world Y of the top of the lowest floor of the level
+ * shown (the sunken room of a split level, not its raised part), the deepest of the levels the hole
+ * is cut over (`belowGradeFootprints` with the same id). `null` when no level is shown or it is
+ * not below grade.
+ */
+export declare function belowGradeFloorY(nodes: Record<AnyNodeId, AnyNode>, shownLevelId?: string | null): number | null;
+/** How far under the top of the floor plate the pit hangs its own floor: the default plate's thickness. */
+export declare const GROUND_PIT_FLOOR_DROP = 0.05;
+/**
+ * How far the pit's floor keeps from the plane of the plate's underside. The foundation under the
+ * level tops out on that plane (`genericFoundation`), and seen through the hole it has to stand
+ * on the pit's floor, not share its plane: two faces on one plane flicker. 2 cm is what a 24-bit
+ * depth buffer with the viewer's 0.3 m near plane tells apart out to about 300 m, further than
+ * the hole is ever looked into from.
+ */
+export declare const GROUND_PIT_PLATE_CLEARANCE = 0.02;
+/**
+ * The world Y the pit under the hole draws its dark floor at, over the level shown: under the top
+ * of its lowest floor (`belowGradeFloorY`) by {@link GROUND_PIT_FLOOR_DROP}, which for the default
+ * plate is exactly its underside, where the footing and the walls on it stop. When that lands
+ * within {@link GROUND_PIT_PLATE_CLEARANCE} of the underside (the default plate, a thinner one, a
+ * plate whose top is the level plane) the floor lies that far under it instead; anywhere else it
+ * keeps to its place. `null` when `belowGradeFloorY` is.
+ */
+export declare function groundPitFloorY(nodes: Record<AnyNodeId, AnyNode>, shownLevelId?: string | null): number | null;
+//# sourceMappingURL=below-grade-footprints.d.ts.map

package/dist/lib/below-grade-footprints.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"below-grade-footprints.d.ts","sourceRoot":"","sources":["../../src/lib/below-grade-footprints.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,WAAW,CAAA;AAgBnD,OAAO,EAAE,KAAK,OAAO,EAAiB,MAAM,iBAAiB,CAAA;AAoE7D;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,EACjC,YAAY,CAAC,EAAE,MAAM,GAAG,IAAI,GAC3B,OAAO,EAAE,EAAE,CAUb;AAID;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,2BAA2B,CAAC,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,GAAG,OAAO,EAAE,EAAE,CA8B1F;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,EACjC,YAAY,CAAC,EAAE,MAAM,GAAG,IAAI,GAC3B,MAAM,GAAG,IAAI,CAGf;AAED,2GAA2G;AAC3G,eAAO,MAAM,qBAAqB,OAAO,CAAA;AACzC;;;;;;GAMG;AACH,eAAO,MAAM,0BAA0B,OAAO,CAAA;AAE9C;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAC7B,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,EACjC,YAAY,CAAC,EAAE,MAAM,GAAG,IAAI,GAC3B,MAAM,GAAG,IAAI,CAQf"}

package/dist/lib/below-grade-footprints.js

@@ -0,0 +1,181 @@
+import { BELOW_GRADE_TOLERANCE, getLevelElevations, levelLowestFloorWorldY, levelPlaneWorldY, levelPlateUndersideWorldY, } from '../services/storey.js';
+import { floorBuriedOnFlatSite, levelGradeStanding, terrainFieldOverLevel, } from './grade-standing.js';
+import { groundOverPart } from './ground-over-part.js';
+import { difference, intersection, union } from './polygon-boolean.js';
+import { unionPolygons } from './polygon-union.js';
+import { isSiteFlatwork } from './site-flatwork.js';
+import { levelLocalToWorldXZ } from './terrain-support-query.js';
+// Identity-keyed memo (`nodes` is an immutable store slice): the standing of every level is worked
+// out once per scene state, however many sets the callers ask for (the hole and the ring ask for
+// the shown stack, the materials for whether any level is buried at all, the ground for what the
+// house covers).
+const platesMemo = new WeakMap();
+function levelPlates(nodes) {
+    const hit = platesMemo.get(nodes);
+    if (hit)
+        return hit;
+    const elevations = getLevelElevations(nodes);
+    const levels = [];
+    for (const level of Object.values(nodes)) {
+        if (level.type !== 'level')
+            continue;
+        const standing = levelGradeStanding(nodes, level.id);
+        const buildingId = elevations.get(level.id)?.buildingId;
+        const building = buildingId ? nodes[buildingId] : undefined;
+        const placed = building?.type === 'building' ? building : null;
+        // A partly buried level is cut slab by slab, each over the ground that stands above its own
+        // floor: a split level's sunken room is buried by ground the raised part's top is above.
+        const plane = standing === 'partly-below-grade' ? levelPlaneWorldY(nodes, level.id) : null;
+        const field = plane === null ? null : terrainFieldOverLevel(nodes, level);
+        const plates = [];
+        const buried = [];
+        for (const childId of level.children) {
+            const slab = nodes[childId];
+            if (slab?.type !== 'slab' || slab.recessed === true || isSiteFlatwork(slab))
+                continue;
+            const plate = slab.polygon.map(([x, z]) => levelLocalToWorldXZ(placed, x, z));
+            plates.push(plate);
+            if (standing === 'at-grade')
+                continue;
+            if (field && plane !== null)
+                buried.push(...groundOverPart(plate, field, plane + slab.elevation + BELOW_GRADE_TOLERANCE));
+            else if (plane !== null) {
+                // A flat site, a level of floors at different heights: a floor is buried or it is not.
+                if (floorBuriedOnFlatSite(plane + slab.elevation))
+                    buried.push(plate);
+            }
+            else
+                buried.push(plate);
+        }
+        levels.push({
+            buildingId,
+            index: level.level,
+            visible: level.visible !== false,
+            standing,
+            plates,
+            buried,
+        });
+    }
+    platesMemo.set(nodes, levels);
+    return levels;
+}
+/**
+ * Where the ground meets the levels below grade, in the site's plan: each such level's floor slabs
+ * placed where its building stands and joined into outlines, the levels' together as one set (a
+ * deeper level wider than the one over it, or under part of it, gives one outline, not overlapping
+ * ones). The 3D view cuts its hole in the ground and draws its grade ring along them while the
+ * ground is veiled. An automatic floor follows the walls' centrelines, so an outline runs half a
+ * wall inside the outer faces. A level only partly below grade (a walk-out on a hillside) gives
+ * the part of its floor the ground stands over by more than {@link BELOW_GRADE_TOLERANCE}, the
+ * edge following the slope; fully buried levels give their whole floor.
+ *
+ * With `shownLevelId`, only what the level display needs open over that level: the level itself and
+ * the levels between it and grade (the ones the display hides above it: `level` index at or over
+ * its own, in every building, as the display decides from the index alone), the levels the author
+ * has hidden left out. The levels deeper than the one shown stay under the ground. Without it,
+ * every level below grade.
+ */
+export function belowGradeFootprints(nodes, shownLevelId) {
+    const shown = shownLevelId ? nodes[shownLevelId] : undefined;
+    const fromIndex = shown?.type === 'level' ? shown.level : Number.NEGATIVE_INFINITY;
+    const floors = [];
+    for (const level of levelPlates(nodes)) {
+        if (level.standing === 'at-grade')
+            continue;
+        if (level.index < fromIndex || (shown && !level.visible))
+            continue;
+        floors.push(...level.buried);
+    }
+    return unionPolygons(floors);
+}
+const coveredMemo = new WeakMap();
+/**
+ * The part of the ground that lies over the house itself: what is below grade under the footprint
+ * of the levels above it, in the site's plan. The house covers it, so the ground can stand open
+ * there whatever level is shown: from outside nothing changes (the storeys are over it), and the
+ * stairwells and floor openings of the stacked view, and the walkthrough on a stair, meet the
+ * basement and not a sheet of ground across it. A below-grade level reaching out under the garden
+ * gives only the part the house stands over; the rest stays closed, no pit in the garden.
+ *
+ * Per building, a level below grade is covered by the floor slabs of the visible levels over it
+ * (`level` index above its own) that are not themselves fully buried: the ones at grade, and the
+ * part of a floor only partly below grade that stands out of the hill. A hidden level covers
+ * nothing and is covered by nothing. Of a level only partly below grade, only the part the ground
+ * stands over is open. A slab's own openings do not count: the stairwell is where the ground
+ * should be open.
+ *
+ * Outlines with an inner outline (a courtyard the house wraps round) are left out: the ground
+ * cannot be cut around an island of itself, and closed is the safe side.
+ */
+export function coveredBelowGradeFootprints(nodes) {
+    const hit = coveredMemo.get(nodes);
+    if (hit)
+        return hit;
+    const levels = levelPlates(nodes);
+    const covered = [];
+    for (const level of levels) {
+        if (level.standing === 'at-grade' || !level.visible || level.buried.length === 0)
+            continue;
+        if (!level.buildingId)
+            continue;
+        const over = [];
+        for (const upper of levels) {
+            if (upper === level ||
+                upper.buildingId !== level.buildingId ||
+                !upper.visible ||
+                upper.index <= level.index ||
+                upper.standing === 'below-grade' ||
+                upper.plates.length === 0)
+                continue;
+            const plates = union(upper.plates);
+            over.push(upper.standing === 'at-grade' ? plates : difference(plates, union(upper.buried)));
+        }
+        if (over.length === 0)
+            continue;
+        covered.push(intersection(union(level.buried), union(over)));
+    }
+    const rings = union(covered.flat().map((polygon) => [polygon]))
+        .filter((polygon) => polygon.holes.length === 0)
+        .map((polygon) => polygon.outer);
+    coveredMemo.set(nodes, rings);
+    return rings;
+}
+/**
+ * How deep the pit under the hole goes: the world Y of the top of the lowest floor of the level
+ * shown (the sunken room of a split level, not its raised part), the deepest of the levels the hole
+ * is cut over (`belowGradeFootprints` with the same id). `null` when no level is shown or it is
+ * not below grade.
+ */
+export function belowGradeFloorY(nodes, shownLevelId) {
+    if (!shownLevelId || levelGradeStanding(nodes, shownLevelId) === 'at-grade')
+        return null;
+    return levelLowestFloorWorldY(nodes, shownLevelId);
+}
+/** How far under the top of the floor plate the pit hangs its own floor: the default plate's thickness. */
+export const GROUND_PIT_FLOOR_DROP = 0.05;
+/**
+ * How far the pit's floor keeps from the plane of the plate's underside. The foundation under the
+ * level tops out on that plane (`genericFoundation`), and seen through the hole it has to stand
+ * on the pit's floor, not share its plane: two faces on one plane flicker. 2 cm is what a 24-bit
+ * depth buffer with the viewer's 0.3 m near plane tells apart out to about 300 m, further than
+ * the hole is ever looked into from.
+ */
+export const GROUND_PIT_PLATE_CLEARANCE = 0.02;
+/**
+ * The world Y the pit under the hole draws its dark floor at, over the level shown: under the top
+ * of its lowest floor (`belowGradeFloorY`) by {@link GROUND_PIT_FLOOR_DROP}, which for the default
+ * plate is exactly its underside, where the footing and the walls on it stop. When that lands
+ * within {@link GROUND_PIT_PLATE_CLEARANCE} of the underside (the default plate, a thinner one, a
+ * plate whose top is the level plane) the floor lies that far under it instead; anywhere else it
+ * keeps to its place. `null` when `belowGradeFloorY` is.
+ */
+export function groundPitFloorY(nodes, shownLevelId) {
+    const floorY = belowGradeFloorY(nodes, shownLevelId);
+    const underside = shownLevelId ? levelPlateUndersideWorldY(nodes, shownLevelId) : null;
+    if (floorY === null || underside === null)
+        return null;
+    const hung = floorY - GROUND_PIT_FLOOR_DROP;
+    return Math.abs(hung - underside) < GROUND_PIT_PLATE_CLEARANCE
+        ? underside - GROUND_PIT_PLATE_CLEARANCE
+        : hung;
+}

package/dist/lib/building-footprint.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Where a building stands on its site: the building node's pose turns its levels' plan
+ * coordinates into site metres, and its walls' bands, unioned, are the footprint the site plan
+ * draws and the setbacks are measured to. Pure: no store.
+ */
+import type { AnyNode, BuildingNode, LevelNode } from '../schema/index.js';
+type Pt = readonly [number, number];
+type Nodes = Readonly<Record<string, AnyNode>>;
+/** A three.js Y rotation of a plan point: local (x, z) turned by `yaw`. */
+export declare function turnPlanPoint(x: number, z: number, yaw: number): Pt;
+export declare function yawOf(rotation: unknown): number;
+/**
+ * Level-local plan (x, z) → site metres, through the building's placement: three.js Y rotation,
+ * the convention BuildingRenderer applies, `site = position + (c·x + s·z, −s·x + c·z)`.
+ */
+export declare function siteFrame(building: Pick<BuildingNode, 'position' | 'rotation'> | null): (x: number, z: number) => Pt;
+/** Site metres → the building's level-local plan (x, z): `siteFrame` inverted. */
+export declare function levelFrame(building: Pick<BuildingNode, 'position' | 'rotation'> | null): (x: number, z: number) => Pt;
+/**
+ * Per-wall plan footprints for a level, mitred, then transformed by the building's site
+ * placement (`siteFrame`); with no building, in the level's own coordinates. `only` keeps the
+ * named walls, still mitred against every wall on the level.
+ */
+export declare function levelFootprintLoops(nodes: Nodes, level: LevelNode | null, building: BuildingNode | null, only?: ReadonlySet<string>): Pt[][];
+/**
+ * The outer ring(s) of a set of wall bands: their union, minus any ring that
+ * lies inside another (a room enclosed by partitions is a hole in the union,
+ * not a second building). Falls back to the bands themselves when the union
+ * yields nothing.
+ */
+export declare function footprintOutline(loops: readonly (readonly Pt[])[]): Pt[][];
+export {};
+//# sourceMappingURL=building-footprint.d.ts.map

package/dist/lib/building-footprint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"building-footprint.d.ts","sourceRoot":"","sources":["../../src/lib/building-footprint.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,KAAK,EAAE,OAAO,EAAE,YAAY,EAAE,SAAS,EAAY,MAAM,WAAW,CAAA;AAK3E,KAAK,EAAE,GAAG,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;AACnC,KAAK,KAAK,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAA;AAE9C,2EAA2E;AAC3E,wBAAgB,aAAa,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,EAAE,CAInE;AAED,wBAAgB,KAAK,CAAC,QAAQ,EAAE,OAAO,GAAG,MAAM,CAI/C;AAED;;;GAGG;AACH,wBAAgB,SAAS,CACvB,QAAQ,EAAE,IAAI,CAAC,YAAY,EAAE,UAAU,GAAG,UAAU,CAAC,GAAG,IAAI,GAC3D,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,KAAK,EAAE,CAQ9B;AAED,kFAAkF;AAClF,wBAAgB,UAAU,CACxB,QAAQ,EAAE,IAAI,CAAC,YAAY,EAAE,UAAU,GAAG,UAAU,CAAC,GAAG,IAAI,GAC3D,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,KAAK,EAAE,CAK9B;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,KAAK,EACZ,KAAK,EAAE,SAAS,GAAG,IAAI,EACvB,QAAQ,EAAE,YAAY,GAAG,IAAI,EAC7B,IAAI,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,GACzB,EAAE,EAAE,EAAE,CAmBR;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,SAAS,CAAC,SAAS,EAAE,EAAE,CAAC,EAAE,GAAG,EAAE,EAAE,EAAE,CAqB1E"}

package/dist/lib/building-footprint.js

@@ -0,0 +1,89 @@
+import { getWallPlanFootprint } from '../systems/wall/wall-footprint.js';
+import { calculateLevelMiters } from '../systems/wall/wall-mitering.js';
+import { unionPolygons } from './polygon-union.js';
+/** A three.js Y rotation of a plan point: local (x, z) turned by `yaw`. */
+export function turnPlanPoint(x, z, yaw) {
+    const c = Math.cos(yaw);
+    const s = Math.sin(yaw);
+    return [c * x + s * z, -s * x + c * z];
+}
+export function yawOf(rotation) {
+    if (typeof rotation === 'number')
+        return rotation;
+    if (Array.isArray(rotation))
+        return Number(rotation[1] ?? 0) || 0;
+    return 0;
+}
+/**
+ * Level-local plan (x, z) → site metres, through the building's placement: three.js Y rotation,
+ * the convention BuildingRenderer applies, `site = position + (c·x + s·z, −s·x + c·z)`.
+ */
+export function siteFrame(building) {
+    const yaw = building?.rotation?.[1] ?? 0;
+    const ox = building?.position?.[0] ?? 0;
+    const oz = building?.position?.[2] ?? 0;
+    return (x, z) => {
+        const [tx, tz] = turnPlanPoint(x, z, yaw);
+        return [ox + tx, oz + tz];
+    };
+}
+/** Site metres → the building's level-local plan (x, z): `siteFrame` inverted. */
+export function levelFrame(building) {
+    const yaw = building?.rotation?.[1] ?? 0;
+    const ox = building?.position?.[0] ?? 0;
+    const oz = building?.position?.[2] ?? 0;
+    return (x, z) => turnPlanPoint(x - ox, z - oz, -yaw);
+}
+/**
+ * Per-wall plan footprints for a level, mitred, then transformed by the building's site
+ * placement (`siteFrame`); with no building, in the level's own coordinates. `only` keeps the
+ * named walls, still mitred against every wall on the level.
+ */
+export function levelFootprintLoops(nodes, level, building, only) {
+    if (!level)
+        return [];
+    const walls = [];
+    for (const childId of level.children ?? []) {
+        const child = nodes[childId];
+        if (child?.type === 'wall')
+            walls.push(child);
+    }
+    if (walls.length === 0)
+        return [];
+    const miters = calculateLevelMiters(walls);
+    const toSite = siteFrame(building);
+    const loops = [];
+    for (const wall of walls) {
+        if (only && !only.has(wall.id))
+            continue;
+        const poly = getWallPlanFootprint(wall, miters);
+        if (poly.length < 3)
+            continue;
+        loops.push(poly.map((p) => toSite(p.x, p.y)));
+    }
+    return loops;
+}
+/**
+ * The outer ring(s) of a set of wall bands: their union, minus any ring that
+ * lies inside another (a room enclosed by partitions is a hole in the union,
+ * not a second building). Falls back to the bands themselves when the union
+ * yields nothing.
+ */
+export function footprintOutline(loops) {
+    const rings = unionPolygons(loops.map((loop) => loop.map((p) => [p[0], p[1]])));
+    if (rings.length === 0)
+        return loops.map((loop) => [...loop]);
+    const inside = (p, ring) => {
+        let hit = false;
+        for (let i = 0, j = ring.length - 1; i < ring.length; j = i++) {
+            const a = ring[i];
+            const b = ring[j];
+            if (a[1] > p[1] !== b[1] > p[1] &&
+                p[0] < ((b[0] - a[0]) * (p[1] - a[1])) / (b[1] - a[1]) + a[0]) {
+                hit = !hit;
+            }
+        }
+        return hit;
+    };
+    return rings.filter((ring, i) => !rings.some((other, j) => j !== i && ring[0] !== undefined && inside(ring[0], other)));
+}