@pascal-app/nodes 0.1.1

package/dist/column/schema.d.ts

@@ -0,0 +1,2 @@
+export { ColumnNode } from '@pascal-app/core';
+//# sourceMappingURL=schema.d.ts.map

package/dist/column/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/column/schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA"}

package/dist/column/schema.js

@@ -0,0 +1 @@
+export { ColumnNode } from '@pascal-app/core';

package/dist/column/slots.d.ts

@@ -0,0 +1,9 @@
+import type { SlotDeclaration } from '@pascal-app/core';
+import type { ColumnNode } from './schema';
+export type ColumnSlotId = 'shaft' | 'base' | 'capital' | 'frame';
+export declare const COLUMN_SHAFT_DEFAULT = "library:concrete-plaster";
+export declare const COLUMN_BASE_DEFAULT = "library:concrete-plaster";
+export declare const COLUMN_CAPITAL_DEFAULT = "library:concrete-plaster";
+export declare const COLUMN_FRAME_DEFAULT = "library:metal-steel";
+export declare function columnSlots(node: ColumnNode): SlotDeclaration[];
+//# sourceMappingURL=slots.d.ts.map

package/dist/column/slots.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slots.d.ts","sourceRoot":"","sources":["../../src/column/slots.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAA;AACvD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAE1C,MAAM,MAAM,YAAY,GAAG,OAAO,GAAG,MAAM,GAAG,SAAS,GAAG,OAAO,CAAA;AAEjE,eAAO,MAAM,oBAAoB,6BAA6B,CAAA;AAC9D,eAAO,MAAM,mBAAmB,6BAA6B,CAAA;AAC7D,eAAO,MAAM,sBAAsB,6BAA6B,CAAA;AAChE,eAAO,MAAM,oBAAoB,wBAAwB,CAAA;AAEzD,wBAAgB,WAAW,CAAC,IAAI,EAAE,UAAU,GAAG,eAAe,EAAE,CAkB/D"}

package/dist/column/slots.js

@@ -0,0 +1,19 @@
+export const COLUMN_SHAFT_DEFAULT = 'library:concrete-plaster';
+export const COLUMN_BASE_DEFAULT = 'library:concrete-plaster';
+export const COLUMN_CAPITAL_DEFAULT = 'library:concrete-plaster';
+export const COLUMN_FRAME_DEFAULT = 'library:metal-steel';
+export function columnSlots(node) {
+    const slots = [
+        { slotId: 'shaft', label: 'Shaft', default: COLUMN_SHAFT_DEFAULT },
+    ];
+    if (node.baseStyle !== 'none') {
+        slots.push({ slotId: 'base', label: 'Base', default: COLUMN_BASE_DEFAULT });
+    }
+    if (node.capitalStyle !== 'none') {
+        slots.push({ slotId: 'capital', label: 'Capital', default: COLUMN_CAPITAL_DEFAULT });
+    }
+    if (node.supportStyle !== 'vertical') {
+        slots.push({ slotId: 'frame', label: 'Frame', default: COLUMN_FRAME_DEFAULT });
+    }
+    return slots;
+}

package/dist/column/tool.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Registry-driven column placement tool. Mirrors the shelf build tool:
+ * a translucent `ColumnPreview` ghost follows the cursor (the piece the
+ * legacy editor-side `ColumnTool` lacked — it only showed a sphere), grid
+ * snap is layered with Figma-style alignment, and a `grid:click` commits.
+ *
+ * Lives in `packages/nodes` (not the editor) specifically so it can import
+ * the column geometry for the ghost — the editor package can't depend on
+ * `nodes`. Wired via `def.tool`, so `ToolManager`'s registry-first path
+ * mounts it and the legacy `<ColumnTool>` branch no longer fires.
+ */
+declare const ColumnTool: () => import("react").JSX.Element | null;
+export default ColumnTool;
+//# sourceMappingURL=tool.d.ts.map

package/dist/column/tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/column/tool.tsx"],"names":[],"mappings":"AA+CA;;;;;;;;;;GAUG;AACH,QAAA,MAAM,UAAU,0CA2Hf,CAAA;AAED,eAAe,UAAU,CAAA"}

package/dist/column/tool.js

@@ -0,0 +1,133 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { COLUMN_PRESETS, ColumnNode, collectAlignmentAnchors, emitter, useScene, } from '@pascal-app/core';
+import { getFloorStackPreviewPosition, isAlignmentGuideActive, isGridSnapActive, isMagneticSnapActive, movementSfxStepKey, triggerSFX, useAlignmentGuides, useEditor, useFacingPose, usePlacementPreview, } from '@pascal-app/editor';
+import { useViewer } from '@pascal-app/viewer';
+import { useEffect, useMemo, useRef, useState } from 'react';
+import { getLevelLocalSnappedPosition, resolveAlignedFloorPlacement, stopPlacementCommitPropagation, subscribeFloorPlacementClicks, } from '../shared/floor-placement';
+import { ColumnPreview } from './renderer';
+const DEFAULT_COLUMN_PRESET_ID = 'basicPillar';
+function createColumnFromPreset(presetId, position) {
+    const { label, ...preset } = COLUMN_PRESETS[presetId];
+    return ColumnNode.parse({
+        name: label,
+        position,
+        rotation: 0,
+        ...preset,
+    });
+}
+/**
+ * Registry-driven column placement tool. Mirrors the shelf build tool:
+ * a translucent `ColumnPreview` ghost follows the cursor (the piece the
+ * legacy editor-side `ColumnTool` lacked — it only showed a sphere), grid
+ * snap is layered with Figma-style alignment, and a `grid:click` commits.
+ *
+ * Lives in `packages/nodes` (not the editor) specifically so it can import
+ * the column geometry for the ghost — the editor package can't depend on
+ * `nodes`. Wired via `def.tool`, so `ToolManager`'s registry-first path
+ * mounts it and the legacy `<ColumnTool>` branch no longer fires.
+ */
+const ColumnTool = () => {
+    const activeLevelId = useViewer((state) => state.selection.levelId);
+    const cursorRef = useRef(null);
+    const previousSnapRef = useRef(null);
+    const cursorVisibleRef = useRef(false);
+    const [cursorVisible, setCursorVisible] = useState(false);
+    // Default-preset column for the placement ghost — matches exactly what the
+    // commit creates (`basicPillar`), so the preview is faithful.
+    const previewNode = useMemo(() => createColumnFromPreset(DEFAULT_COLUMN_PRESET_ID, [0, 0, 0]), []);
+    useEffect(() => {
+        if (!activeLevelId)
+            return;
+        previousSnapRef.current = null;
+        cursorVisibleRef.current = false;
+        setCursorVisible(false);
+        const lastCursorRef = { current: null };
+        // Alignment candidates — anchors of every other alignable object, gathered
+        // here and refreshed after each placement so a just-placed column becomes a
+        // target for the next one. `previewNode.id` never collides with a scene
+        // node, so nothing real is excluded.
+        let alignmentCandidates = collectAlignmentAnchors(useScene.getState().nodes, previewNode.id);
+        const onGridMove = (event) => {
+            if (!cursorVisibleRef.current) {
+                cursorVisibleRef.current = true;
+                setCursorVisible(true);
+            }
+            const { position, guides } = resolveAlignedFloorPlacement({
+                node: previewNode,
+                rawX: event.localPosition[0],
+                rawZ: event.localPosition[2],
+                gridStep: useEditor.getState().gridSnapStep,
+                candidates: alignmentCandidates,
+                showAlignment: isAlignmentGuideActive(),
+                applyAlignmentSnap: isMagneticSnapActive(),
+                bypassGrid: !isGridSnapActive(),
+            });
+            useAlignmentGuides.getState().set(guides);
+            const visualPosition = getFloorStackPreviewPosition({
+                node: previewNode,
+                position,
+                rotation: previewNode.rotation,
+                levelId: activeLevelId,
+            });
+            cursorRef.current?.position.set(...visualPosition);
+            // Forward-facing floor triangle, drawn by the editor-side overlay. Columns
+            // never rotate (`rotation: 0`), so the triangle just sits in front.
+            useFacingPose.getState().set({
+                position: visualPosition,
+                rotationY: previewNode.rotation,
+                depth: previewNode.depth,
+            });
+            lastCursorRef.current = position;
+            // Publish a transient, positioned preview node for the 2D floor-plan
+            // ghost (the 3D `ColumnPreview` mesh is hidden in 2D). The floor-plan
+            // placement-preview layer renders this node's footprint at the snapped,
+            // aligned cursor so users see the pillar before they click.
+            usePlacementPreview.getState().set({ ...previewNode, position });
+            const nextSnapKey = movementSfxStepKey({
+                coords: [position[0], position[2]],
+                gridSnapActive: isGridSnapActive(),
+                gridStep: useEditor.getState().gridSnapStep,
+            });
+            const prev = previousSnapRef.current;
+            if (prev !== nextSnapKey) {
+                triggerSFX('sfx:grid-snap');
+                previousSnapRef.current = nextSnapKey;
+            }
+        };
+        const commitAtCursor = (event) => {
+            const position = lastCursorRef.current ??
+                getLevelLocalSnappedPosition(activeLevelId, event, useEditor.getState().gridSnapStep, !isGridSnapActive());
+            const column = createColumnFromPreset(DEFAULT_COLUMN_PRESET_ID, position);
+            useScene.getState().createNode(column, activeLevelId);
+            useViewer.getState().setSelection({ selectedIds: [column.id] });
+            triggerSFX('sfx:structure-build');
+            useAlignmentGuides.getState().clear();
+            usePlacementPreview.getState().clear();
+            if (useEditor.getState().getContinuation('point') === 'repeat') {
+                // The placed column is now a valid alignment target for the next one.
+                alignmentCandidates = collectAlignmentAnchors(useScene.getState().nodes, previewNode.id);
+            }
+            else {
+                cursorVisibleRef.current = false;
+                setCursorVisible(false);
+                useFacingPose.getState().clear();
+                useEditor.getState().setTool(null);
+            }
+            stopPlacementCommitPropagation(event);
+        };
+        emitter.on('grid:move', onGridMove);
+        const unsubscribePlacementClicks = subscribeFloorPlacementClicks(commitAtCursor);
+        return () => {
+            emitter.off('grid:move', onGridMove);
+            unsubscribePlacementClicks();
+            useAlignmentGuides.getState().clear();
+            usePlacementPreview.getState().clear();
+            useFacingPose.getState().clear();
+        };
+    }, [activeLevelId, previewNode]);
+    if (!activeLevelId)
+        return null;
+    return (_jsx("group", { ref: cursorRef, visible: cursorVisible, children: _jsx(ColumnPreview, { node: previewNode }) }));
+};
+export default ColumnTool;

package/dist/cupola/definition.d.ts

@@ -0,0 +1,11 @@
+import { type NodeDefinition } from '@pascal-app/core';
+import { CupolaNode } from './schema';
+/**
+ * Cupola — a louvered roof lantern. Parented to a `roof-segment`; position
+ * is segment-local; rotation rotates it around the segment's vertical axis
+ * after the slope tilt is applied. Same composition as the box vent (custom
+ * renderer, pure geometry builder, no system) — see box-vent's definition
+ * for the rationale on why roof accessories need a custom renderer.
+ */
+export declare const cupolaDefinition: NodeDefinition<typeof CupolaNode>;
+//# sourceMappingURL=definition.d.ts.map

package/dist/cupola/definition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/cupola/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,cAAc,EACpB,MAAM,kBAAkB,CAAA;AAIzB,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AA4FrC;;;;;;GAMG;AACH,eAAO,MAAM,gBAAgB,EAAE,cAAc,CAAC,OAAO,UAAU,CAwD9D,CAAA"}

package/dist/cupola/definition.js

@@ -0,0 +1,143 @@
+import { CupolaNode as CupolaNodeSchema, } from '@pascal-app/core';
+import { surfacePaintCapability } from '../shared/surface-paint';
+import { buildCupolaFloorplan } from './floorplan';
+import { cupolaParametrics } from './parametrics';
+import { CupolaNode } from './schema';
+const SIDE_HANDLE_OFFSET = 0.3;
+const HEIGHT_HANDLE_OFFSET = 0.25;
+// Snug to the cupola corner so the rotate icon stays close to the item.
+const ROTATE_CORNER_OFFSET = 0.12;
+const MIN_DIM = 0.3;
+const MIN_HEIGHT = 0.4;
+function getBodyMidY(n) {
+    return Math.max(0.001, n.height) / 2;
+}
+// Width / depth grow symmetrically from the centre (cupolas are placed by
+// their centre on the ridge), so a single centred chevron per axis.
+function cupolaWidthHandle() {
+    return {
+        kind: 'linear-resize',
+        axis: 'x',
+        anchor: 'center',
+        min: MIN_DIM,
+        currentValue: (n) => n.width,
+        apply: (_n, newValue) => ({ width: Math.max(MIN_DIM, newValue) }),
+        placement: {
+            position: (n) => [n.width / 2 + SIDE_HANDLE_OFFSET, getBodyMidY(n), 0],
+        },
+    };
+}
+function cupolaDepthHandle() {
+    return {
+        kind: 'linear-resize',
+        axis: 'z',
+        anchor: 'center',
+        min: MIN_DIM,
+        currentValue: (n) => n.depth,
+        apply: (_n, newValue) => ({ depth: Math.max(MIN_DIM, newValue) }),
+        placement: {
+            position: (n) => [0, getBodyMidY(n), n.depth / 2 + SIDE_HANDLE_OFFSET],
+        },
+    };
+}
+function cupolaHeightHandle() {
+    return {
+        kind: 'linear-resize',
+        axis: 'y',
+        anchor: 'min',
+        min: MIN_HEIGHT,
+        currentValue: (n) => n.height,
+        apply: (_n, newValue) => ({ height: Math.max(MIN_HEIGHT, newValue) }),
+        placement: {
+            position: (n) => [0, Math.max(n.height, MIN_HEIGHT) + HEIGHT_HANDLE_OFFSET, 0],
+        },
+    };
+}
+function cupolaRotateHandle() {
+    return {
+        kind: 'arc-resize',
+        axis: 'angular',
+        shape: 'rotate',
+        apply: (initial, delta) => ({ rotation: (initial.rotation ?? 0) - delta }),
+        placement: {
+            position: (n) => [
+                n.width / 2 + ROTATE_CORNER_OFFSET,
+                getBodyMidY(n),
+                n.depth / 2 + ROTATE_CORNER_OFFSET,
+            ],
+            rotationY: () => -Math.PI / 4,
+        },
+        // Guide ring centred on the cupola, sized to pass through the corner
+        // icon so the icon rides the ring — matches solar-panel / skylight.
+        decoration: {
+            kind: 'ring',
+            radius: (n) => Math.hypot(n.width / 2 + ROTATE_CORNER_OFFSET, n.depth / 2 + ROTATE_CORNER_OFFSET),
+            y: (n) => getBodyMidY(n),
+        },
+    };
+}
+// `portal: 'grandparent'` on every handle — see box-vent's note. The cupola
+// rides the roof→segment→node frame chain, so the handle rig must too, or
+// the handles (and rotate arc) render offset from the cupola.
+const cupolaHandles = [
+    cupolaWidthHandle(),
+    cupolaDepthHandle(),
+    cupolaHeightHandle(),
+    cupolaRotateHandle(),
+].map((h) => ({ ...h, portal: 'grandparent' }));
+/**
+ * Cupola — a louvered roof lantern. Parented to a `roof-segment`; position
+ * is segment-local; rotation rotates it around the segment's vertical axis
+ * after the slope tilt is applied. Same composition as the box vent (custom
+ * renderer, pure geometry builder, no system) — see box-vent's definition
+ * for the rationale on why roof accessories need a custom renderer.
+ */
+export const cupolaDefinition = {
+    kind: 'cupola',
+    schemaVersion: 1,
+    schema: CupolaNode,
+    category: 'structure',
+    surfaceRole: 'roof',
+    defaults: () => {
+        const stub = CupolaNodeSchema.parse({ id: 'cupola_default', type: 'cupola' });
+        const { id: _id, type: _type, ...rest } = stub;
+        return rest;
+    },
+    capabilities: {
+        selectable: { hitVolume: 'bbox' },
+        duplicable: true,
+        deletable: true,
+        // Single painted surface — registry-driven paint dispatch (see chimney).
+        paint: surfacePaintCapability,
+        // Mounts on a roof segment via `roofSegmentId`. Sits ON TOP of the
+        // slope — no `buildCut`, just the dirty cascade so the parent roof's
+        // merged shell rebuilds when the cupola moves / resizes.
+        roofAccessory: {},
+    },
+    parametrics: cupolaParametrics,
+    handles: cupolaHandles,
+    floorplan: buildCupolaFloorplan,
+    renderer: {
+        kind: 'parametric',
+        module: () => import('./renderer'),
+    },
+    preview: () => import('./preview'),
+    tool: () => import('./tool'),
+    affordanceTools: {
+        move: () => import('./move-tool'),
+    },
+    toolHints: [
+        { key: 'Left click', label: 'Place cupola on roof' },
+        { key: 'Esc', label: 'Cancel' },
+    ],
+    presentation: {
+        label: 'Cupola',
+        description: 'Louvered roof lantern with a dome or pyramid cap and optional finial.',
+        icon: { kind: 'url', src: '/icons/roof.webp' },
+        paletteSection: 'structure',
+        paletteOrder: 122,
+    },
+    mcp: {
+        description: 'A louvered cupola (roof lantern) on a roof segment. Roof style: dome / pyramid, optional finial. Parametric width/depth/height.',
+    },
+};

package/dist/cupola/floorplan.d.ts

@@ -0,0 +1,9 @@
+import type { CupolaNode, FloorplanGeometry, GeometryContext } from '@pascal-app/core';
+/**
+ * Floor-plan builder for a cupola — seen from above it reads as the
+ * overhanging cornice/roof square with the louvered body square inside.
+ * Coordinate frame mirrors the 3D transform stack (roof → roof-segment →
+ * cupola), same as the box-vent builder.
+ */
+export declare function buildCupolaFloorplan(node: CupolaNode, ctx: GeometryContext): FloorplanGeometry | null;
+//# sourceMappingURL=floorplan.d.ts.map

package/dist/cupola/floorplan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/cupola/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,UAAU,EACV,iBAAiB,EAEjB,eAAe,EAGhB,MAAM,kBAAkB,CAAA;AAEzB;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,UAAU,EAChB,GAAG,EAAE,eAAe,GACnB,iBAAiB,GAAG,IAAI,CA2F1B"}

package/dist/cupola/floorplan.js

@@ -0,0 +1,89 @@
+/**
+ * Floor-plan builder for a cupola — seen from above it reads as the
+ * overhanging cornice/roof square with the louvered body square inside.
+ * Coordinate frame mirrors the 3D transform stack (roof → roof-segment →
+ * cupola), same as the box-vent builder.
+ */
+export function buildCupolaFloorplan(node, ctx) {
+    const segment = ctx.parent;
+    if (segment?.type !== 'roof-segment')
+        return null;
+    const roofId = segment.parentId;
+    const roof = roofId ? ctx.resolve(roofId) : undefined;
+    if (roof?.type !== 'roof')
+        return null;
+    const cosR = Math.cos(-roof.rotation);
+    const sinR = Math.sin(-roof.rotation);
+    const segCx = roof.position[0] + segment.position[0] * cosR - segment.position[2] * sinR;
+    const segCz = roof.position[2] + segment.position[0] * sinR + segment.position[2] * cosR;
+    const segRot = -(roof.rotation + segment.rotation);
+    const cosS = Math.cos(segRot);
+    const sinS = Math.sin(segRot);
+    const cx = segCx + node.position[0] * cosS - node.position[2] * sinS;
+    const cz = segCz + node.position[0] * sinS + node.position[2] * cosS;
+    const rot = -(roof.rotation + segment.rotation + node.rotation);
+    const cos = Math.cos(rot);
+    const sin = Math.sin(rot);
+    const toPlan = (lx, lz) => [
+        cx + lx * cos - lz * sin,
+        cz + lx * sin + lz * cos,
+    ];
+    const view = ctx.viewState;
+    const palette = view?.palette;
+    const isSelected = view?.selected ?? false;
+    const isHighlighted = view?.highlighted ?? false;
+    const isHovered = view?.hovered ?? false;
+    const showSelectedChrome = isSelected || isHighlighted;
+    const baseInk = '#475569';
+    const stroke = showSelectedChrome && palette
+        ? palette.selectedStroke
+        : isHovered && palette
+            ? palette.wallHoverStroke
+            : baseInk;
+    const fill = showSelectedChrome ? '#fed7aa' : '#dbe1e8';
+    const fillOpacity = showSelectedChrome ? 0.55 : 0.7;
+    const lineWidth = showSelectedChrome ? 0.03 : 0.02;
+    const hw = Math.max(node.width, 0.1) / 2;
+    const hd = Math.max(node.depth, 0.1) / 2;
+    const cornOvh = Math.min(hw, hd) * 0.22;
+    const rect = (halfX, halfZ) => [
+        toPlan(-halfX, -halfZ),
+        toPlan(halfX, -halfZ),
+        toPlan(halfX, halfZ),
+        toPlan(-halfX, halfZ),
+    ];
+    const children = [];
+    // Cornice / roof footprint — outer outline + hit target.
+    const outer = rect(hw + cornOvh, hd + cornOvh);
+    children.push({
+        kind: 'polygon',
+        points: outer,
+        fill: stroke,
+        fillOpacity: 0,
+        stroke: 'none',
+        strokeWidth: 0,
+        pointerEvents: 'all',
+    });
+    children.push({
+        kind: 'polygon',
+        points: outer,
+        fill,
+        fillOpacity,
+        stroke,
+        strokeWidth: lineWidth,
+        strokeLinejoin: 'miter',
+        pointerEvents: 'none',
+    });
+    // Louvered body footprint inside the cornice.
+    children.push({
+        kind: 'polygon',
+        points: rect(hw, hd),
+        fill: 'none',
+        stroke,
+        strokeWidth: lineWidth * 0.8,
+        strokeOpacity: 0.7,
+        strokeLinejoin: 'miter',
+        pointerEvents: 'none',
+    });
+    return { kind: 'group', children };
+}

package/dist/cupola/geometry.d.ts

@@ -0,0 +1,23 @@
+import type { CupolaNode } from '@pascal-app/core';
+import * as THREE from 'three';
+/**
+ * Pure builder for the cupola mesh — a small louvered roof lantern:
+ *
+ *        ✦            ← finial (post + ball)
+ *       /\
+ *      /  \           ← roof (dome or pyramid)
+ *     /____\
+ *    |‖‖‖‖‖‖|          ← louvered body (angled slats on 4 faces)
+ *    |‖‖‖‖‖‖|
+ *   _|______|_
+ *  |__________|        ← base plinth, seats on the roof
+ *
+ * Built bottom → top from primitive revolves / boxes. Every face is placed
+ * through a winding-safe oriented quad/tri, so the whole thing is lit
+ * correctly from outside without hand-traced winding.
+ *
+ * Pure: no React, no scene access, no store mutation. Safe for unit tests,
+ * the placement preview, and the move-tool ghost.
+ */
+export declare function buildCupolaGeometry(node: CupolaNode): THREE.BufferGeometry;
+//# sourceMappingURL=geometry.d.ts.map

package/dist/cupola/geometry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"geometry.d.ts","sourceRoot":"","sources":["../../src/cupola/geometry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAClD,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAE9B;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,UAAU,GAAG,KAAK,CAAC,cAAc,CA2D1E"}